mirror of
https://github.com/SoftFever/OrcaSlicer.git
synced 2025-08-08 06:24:01 -06:00
2ae2672ee9
Fixing dep build script on Windows and removing some warnings. Use bundled igl by default. Not building with the dependency scripts if not explicitly stated. This way, it will stay in Fix the libigl patch to include C source files in header only mode.
286 lines
9.2 KiB
C++
286 lines
9.2 KiB
C++
// This file is part of libigl, a simple c++ geometry processing library.
|
|
//
|
|
// Copyright (C) 2013 Alec Jacobson <alecjacobson@gmail.com>
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla Public License
|
|
// v. 2.0. If a copy of the MPL was not distributed with this file, You can
|
|
// obtain one at http://mozilla.org/MPL/2.0/.
|
|
#ifndef IGL_ANTTWEAKBAR_REANTTWEAKBAR_H
|
|
#define IGL_ANTTWEAKBAR_REANTTWEAKBAR_H
|
|
#include "../igl_inline.h"
|
|
// ReAntTweakBar is a minimal wrapper for the AntTweakBar library that allows
|
|
// "bars" to be saved and load from disk. Changing your existing app that uses
|
|
// AntTweakBar to use ReAntTweakBar is trivial.
|
|
//
|
|
// Many (but not all) variable types are supported. I'll try to keep track them
|
|
// here:
|
|
// TW_TYPE_BOOLCPP
|
|
// TW_TYPE_QUAT4F
|
|
// TW_TYPE_QUAT4D
|
|
// TW_TYPE_COLOR4F
|
|
// TW_TYPE_COLOR4D
|
|
// TW_TYPE_COLOR3F
|
|
// TW_TYPE_DIR3F
|
|
// TW_TYPE_DIR3D
|
|
// TW_TYPE_BOOL32
|
|
// TW_TYPE_INT32
|
|
// TW_TYPE_UINT32
|
|
// TW_TYPE_FLOAT
|
|
// TW_TYPE_DOUBLE
|
|
// TW_TYPE_UINT8
|
|
// and
|
|
// custom TwTypes made with TwDefineEnum
|
|
//
|
|
// I'm working on adding the rest on an as-needed basis. Adding a new type only
|
|
// requires changes in a few places...
|
|
//
|
|
//
|
|
//
|
|
|
|
// This allows the user to have a non-global, static installation of
|
|
// AntTweakBar
|
|
#include <AntTweakBar.h>
|
|
// Instead of including AntTweakBar.h, just define the necessary types
|
|
// Types used:
|
|
// - TwType
|
|
// - TwEnumVal
|
|
// - TwSetVarCallback
|
|
// - TwGetVarCallback
|
|
// - TwBar
|
|
// - TwButtonCallback
|
|
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
|
|
#define REANTTWEAKBAR_MAX_CB_VAR_SIZE 1000
|
|
// Max line size for reading files
|
|
#define REANTTWEAKBAR_MAX_LINE 1000
|
|
#define REANTTWEAKBAR_MAX_WORD 100
|
|
|
|
namespace igl
|
|
{
|
|
namespace anttweakbar
|
|
{
|
|
TwType ReTwDefineEnum(
|
|
const char *name,
|
|
const TwEnumVal *enumValues,
|
|
unsigned int nbValues);
|
|
TwType ReTwDefineEnumFromString(const char * name,const char * enumString);
|
|
|
|
struct ReTwRWItem
|
|
{
|
|
//const char * name;
|
|
std::string name;
|
|
TwType type;
|
|
void * var;
|
|
// Default constructor
|
|
IGL_INLINE ReTwRWItem(
|
|
const std::string _name,
|
|
TwType _type,
|
|
void *_var):
|
|
name(_name),
|
|
type(_type),
|
|
var(_var)
|
|
{
|
|
}
|
|
// Shallow copy constructor
|
|
// I solemnly swear it's OK to copy var this way
|
|
// Q: Is it really?
|
|
IGL_INLINE ReTwRWItem(const ReTwRWItem & that):
|
|
name(that.name),
|
|
type(that.type),
|
|
var(that.var)
|
|
{
|
|
}
|
|
// Shallow assignment
|
|
// I solemnly swear it's OK to copy var this way
|
|
IGL_INLINE ReTwRWItem & operator=(const ReTwRWItem & that)
|
|
{
|
|
if(this != &that)
|
|
{
|
|
this->name = that.name;
|
|
this->type = that.type;
|
|
this->var = that.var;
|
|
}
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
struct ReTwCBItem
|
|
{
|
|
//const char * name;
|
|
std::string name;
|
|
TwType type;
|
|
TwSetVarCallback setCallback;
|
|
TwGetVarCallback getCallback;
|
|
void * clientData;
|
|
// Default constructor
|
|
IGL_INLINE ReTwCBItem(
|
|
const std::string _name,
|
|
TwType _type,
|
|
TwSetVarCallback _setCallback,
|
|
TwGetVarCallback _getCallback,
|
|
void * _clientData):
|
|
name(_name),
|
|
type(_type),
|
|
setCallback(_setCallback),
|
|
getCallback(_getCallback),
|
|
clientData(_clientData)
|
|
{
|
|
}
|
|
// Shallow copy
|
|
// I solemnly swear it's OK to copy clientData this way
|
|
IGL_INLINE ReTwCBItem(const ReTwCBItem & that):
|
|
name(that.name),
|
|
type(that.type),
|
|
setCallback(that.setCallback),
|
|
getCallback(that.getCallback),
|
|
clientData(that.clientData)
|
|
{
|
|
}
|
|
// Shallow assignment
|
|
// I solemnly swear it's OK to copy clientData this way
|
|
IGL_INLINE ReTwCBItem & operator=(const ReTwCBItem & that)
|
|
{
|
|
if(this != &that)
|
|
{
|
|
name = that.name;
|
|
type = that.type;
|
|
setCallback = that.setCallback;
|
|
getCallback = that.getCallback;
|
|
clientData = that.clientData;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
};
|
|
|
|
class ReTwBar
|
|
{
|
|
// VARIABLES
|
|
// Should be private, but seeing as I'm not going to implement all of the
|
|
// AntTweakBar public functions right away, I'll expose this so that at
|
|
// anytime AntTweakBar functions can be called directly on the bar
|
|
public:
|
|
TwBar * bar;
|
|
std::string name;
|
|
protected:
|
|
std::vector<ReTwRWItem> rw_items;
|
|
std::vector<ReTwCBItem> cb_items;
|
|
public:
|
|
// Default constructor with explicit initialization
|
|
IGL_INLINE ReTwBar();
|
|
private:
|
|
// Copy constructor does shallow copy
|
|
IGL_INLINE ReTwBar(const ReTwBar & that);
|
|
// Assignment operator does shallow assignment
|
|
IGL_INLINE ReTwBar &operator=(const ReTwBar & that);
|
|
|
|
// WRAPPERS FOR ANTTWEAKBAR FUNCTIONS
|
|
public:
|
|
IGL_INLINE void TwNewBar(const char *_name);
|
|
IGL_INLINE int TwAddVarRW(
|
|
const char *name,
|
|
TwType type,
|
|
void *var,
|
|
const char *def,
|
|
const bool record=true);
|
|
IGL_INLINE int TwAddVarCB(
|
|
const char *name,
|
|
TwType type,
|
|
TwSetVarCallback setCallback,
|
|
TwGetVarCallback getCallback,
|
|
void *clientData,
|
|
const char *def,
|
|
const bool record=true);
|
|
// Wrappers for convenience (not recorded, just passed on)
|
|
IGL_INLINE int TwAddVarRO(const char *name, TwType type, void *var, const char *def);
|
|
IGL_INLINE int TwAddButton(
|
|
const char *name,
|
|
TwButtonCallback buttonCallback,
|
|
void *clientData,
|
|
const char *def);
|
|
IGL_INLINE int TwSetParam(
|
|
const char *varName,
|
|
const char *paramName,
|
|
TwParamValueType paramValueType,
|
|
unsigned int inValueCount,
|
|
const void *inValues);
|
|
IGL_INLINE int TwGetParam(
|
|
const char *varName,
|
|
const char *paramName,
|
|
TwParamValueType paramValueType,
|
|
unsigned int outValueMaxCount,
|
|
void *outValues);
|
|
IGL_INLINE int TwRefreshBar();
|
|
IGL_INLINE int TwTerminate();
|
|
|
|
|
|
// IO FUNCTIONS
|
|
public:
|
|
// Save current items to file
|
|
// Input:
|
|
// file_name name of file to save data to, can be null which means print
|
|
// to stdout
|
|
// Return:
|
|
// true only if there were no (fatal) errors
|
|
IGL_INLINE bool save(const char *file_name);
|
|
std::string get_value_as_string(
|
|
void * var,
|
|
TwType type);
|
|
// Load into current items from file
|
|
// Input:
|
|
// file_name name of input file to load
|
|
// Return:
|
|
// true only if there were no (fatal) errors
|
|
IGL_INLINE bool load(const char *file_name);
|
|
// Get TwType from string
|
|
// Input
|
|
// type_str string of type
|
|
// Output
|
|
// type TwType converted from string
|
|
// Returns
|
|
// true only if string matched a valid type
|
|
IGL_INLINE bool type_from_string(const char *type_str, TwType & type);
|
|
// I realize that I mix std::string and const char * all over the place.
|
|
// What can you do...
|
|
IGL_INLINE bool set_value_from_string(
|
|
const char * name,
|
|
TwType type,
|
|
const char * value_str);
|
|
IGL_INLINE const std::vector<ReTwRWItem> & get_rw_items();
|
|
IGL_INLINE const std::vector<ReTwCBItem> & get_cb_items();
|
|
};
|
|
}
|
|
}
|
|
|
|
// List of TwBar functions
|
|
//TW_API TwBar * TW_CALL TwNewBar(const char *barName);
|
|
//TW_API int TW_CALL TwDeleteBar(TwBar *bar);
|
|
//TW_API int TW_CALL TwDeleteAllBars();
|
|
//TW_API int TW_CALL TwSetTopBar(const TwBar *bar);
|
|
//TW_API TwBar * TW_CALL TwGetTopBar();
|
|
//TW_API int TW_CALL TwSetBottomBar(const TwBar *bar);
|
|
//TW_API TwBar * TW_CALL TwGetBottomBar();
|
|
//TW_API const char * TW_CALL TwGetBarName(TwBar *bar);
|
|
//TW_API int TW_CALL TwGetBarCount();
|
|
//TW_API TwBar * TW_CALL TwGetBarByIndex(int barIndex);
|
|
//TW_API TwBar * TW_CALL TwGetBarByName(const char *barName);
|
|
//TW_API int TW_CALL TwRefreshBar(TwBar *bar);
|
|
//TW_API int TW_CALL TwTerminate();
|
|
//
|
|
//TW_API int TW_CALL TwAddVarRW(TwBar *bar, const char *name, TwType type, void *var, const char *def);
|
|
//TW_API int TW_CALL TwAddVarRO(TwBar *bar, const char *name, TwType type, const void *var, const char *def);
|
|
//TW_API int TW_CALL TwAddVarCB(TwBar *bar, const char *name, TwType type, TwSetVarCallback setCallback, TwGetVarCallback getCallback, void *clientData, const char *def);
|
|
//TW_API int TW_CALL TwAddButton(TwBar *bar, const char *name, TwButtonCallback callback, void *clientData, const char *def);
|
|
//TW_API int TW_CALL TwAddSeparator(TwBar *bar, const char *name, const char *def);
|
|
//TW_API int TW_CALL TwRemoveVar(TwBar *bar, const char *name);
|
|
//TW_API int TW_CALL TwRemoveAllVars(TwBar *bar);
|
|
|
|
// Until AntTweakBar dependency folder exists, this is header-only
|
|
#ifndef IGL_STATIC_LIBRARY
|
|
# include "ReAntTweakBar.cpp"
|
|
#endif
|
|
|
|
#endif
|