username
stringlengths 1
36
| repo
stringlengths 1
82
| path
stringlengths 4
161
| function
stringlengths 0
328
| code
stringlengths 15
240k
| func_defs
stringlengths 0
313k
| llvm
stringclasses 1
value | hash
stringlengths 64
64
| memory
int64 15
240k
|
---|---|---|---|---|---|---|---|---|
cran | rgl | src/subscene.cpp | Subscene::hideViewpoint |
void Subscene::hideViewpoint(int id)
{
if (userviewpoint && sameID(userviewpoint, id)) {
if (parent)
userviewpoint = NULL;
} else if (modelviewpoint && sameID(modelviewpoint, id)) {
if (parent)
modelviewpoint = NULL;
}
} |
Subscene::~Subscene();
bool Subscene::add(SceneNode* node);
void Subscene::addBackground(Background* newbackground);
void Subscene::addBBoxDeco(BBoxDeco* newbboxdeco);
void Subscene::addShape(Shape* shape);
void Subscene::addBBox(const AABox& bbox, bool changes);
void Subscene::addLight(Light* light);
void Subscene::addSubscene(Subscene* subscene);
void Subscene::hideShape(int id);
void Subscene::hideLight(int id);
void Subscene::hideBBoxDeco(int id);
void Subscene::hideBackground(int id);
Subscene* Subscene::hideSubscene(int id, Subscene* current);
Subscene* Subscene::getSubscene(int id);
Subscene* Subscene::whichSubscene(int id);
Subscene* Subscene::whichSubscene(int mouseX, int mouseY);
int Subscene::getAttributeCount(SceneNode* subscene, AttribID attrib);
void Subscene::getAttribute(SceneNode* subscene, AttribID attrib, int first, int count, double* result);
String Subscene::getTextAttribute(SceneNode* subscene, AttribID attrib, int index);
void Subscene::renderClipplanes(RenderContext* renderContext);
void Subscene::disableClipplanes(RenderContext* renderContext);
int Subscene::get_id_count(TypeID type, bool recursive);
int Subscene::get_ids(TypeID type, int* ids, char** types, bool recursive);
Background* Subscene::get_background();
Background* Subscene::get_background(int id);
BBoxDeco* Subscene::get_bboxdeco();
BBoxDeco* Subscene::get_bboxdeco(int id);
UserViewpoint* Subscene::getUserViewpoint();
ModelViewpoint* Subscene::getModelViewpoint();
void Subscene::update(RenderContext* renderContext);
void Subscene::loadMatrices();
void Subscene::render(RenderContext* renderContext, bool opaquePass);
void Subscene::calcDataBBox();
void Subscene::intersectClipplanes(void);
void Subscene::newBBox(void);
void Subscene::setIgnoreExtent(int in_ignoreExtent);
void Subscene::setupViewport(RenderContext* rctx);
void Subscene::setupProjMatrix(RenderContext* rctx);
void Subscene::setupModelViewMatrix(RenderContext* rctx);
void Subscene::setupModelMatrix(RenderContext* rctx);
Sphere Subscene::getViewSphere();
void Subscene::disableLights(RenderContext* rctx);
void Subscene::setupLights(RenderContext* rctx);
void Subscene::renderUnsorted(RenderContext* renderContext);
void Subscene::renderZsort(RenderContext* renderContext);
const AABox& Subscene::getBoundingBox();
void Subscene::newEmbedding();
void Subscene::setEmbedding(int which, Embedding value);
Embedding Subscene::getEmbedding(Embedded which);
Subscene* Subscene::getMaster(Embedded which);
void Subscene::getUserMatrix(double* dest);
void Subscene::setUserMatrix(double* src);
void Subscene::getUserProjection(double* dest);
void Subscene::setUserProjection(double* src);
void Subscene::getScale(double* dest);
void Subscene::setScale(double* src);
void Subscene::getPosition(double* dest);
void Subscene::setPosition(double* src);
void Subscene::setViewport(double x, double y, double width, double height);
void Subscene::clearMouseListeners();
void Subscene::addMouseListener(Subscene* sub);
void Subscene::deleteMouseListener(Subscene* sub);
void Subscene::getMouseListeners(size_t max, int* ids);
float Subscene::getDistance(const Vertex& v);
viewControlPtr Subscene::getButtonBeginFunc(int button);
void Subscene::buttonBegin(int button, int mouseX, int mouseY);
viewControlPtr Subscene::getButtonUpdateFunc(int button);
void Subscene::buttonUpdate(int button, int mouseX, int mouseY);
viewControlEndPtr Subscene::getButtonEndFunc(int button);
void Subscene::buttonEnd(int button);
void Subscene::setDefaultMouseMode();
bool Subscene::mouseNeedsWatching();
void Subscene::setMouseMode(int button, MouseModeID mode);
MouseModeID Subscene::getMouseMode(int button);
void Subscene::setWheelCallback(userWheelPtr wheel, void* user);
void Subscene::getWheelCallback(userWheelPtr *wheel, void** user);
static PolarCoord screenToPolar(int width, int height, int mouseX, int mouseY);
static Vertex screenToVector(int width, int height, int mouseX, int mouseY);
void Subscene::trackballBegin(int mouseX, int mouseY);
void Subscene::trackballUpdate(int mouseX, int mouseY);
void Subscene::trackballEnd();
void Subscene::oneAxisBegin(int mouseX, int mouseY);
void Subscene::oneAxisUpdate(int mouseX, int mouseY);
void Subscene::polarBegin(int mouseX, int mouseY);
void Subscene::polarUpdate(int mouseX, int mouseY);
void Subscene::polarEnd();
void Subscene::adjustFOVBegin(int mouseX, int mouseY);
void Subscene::adjustFOVUpdate(int mouseX, int mouseY);
void Subscene::adjustFOVEnd();
void Subscene::wheelRotatePull(int dir);
void Subscene::wheelRotatePush(int dir);
void Subscene::wheelRotate(int dir);
void Subscene::userBegin(int mouseX, int mouseY);
void Subscene::userUpdate(int mouseX, int mouseY);
void Subscene::userEnd();
void Subscene::userWheel(int dir);
void Subscene::adjustZoomBegin(int mouseX, int mouseY);
void Subscene::adjustZoomUpdate(int mouseX, int mouseY);
void Subscene::adjustZoomEnd();
double* Subscene::getMousePosition();
MouseSelectionID Subscene::getSelectState();
void Subscene::setSelectState(MouseSelectionID state);
void Subscene::mouseSelectionBegin(int mouseX,int mouseY);
void Subscene::mouseSelectionUpdate(int mouseX,int mouseY);
void Subscene::mouseSelectionEnd();
Subscene* Subscene::getRootSubscene();
| 0400076bd29b49f873dfdf4f8edefe98f514e9a74ca58baab9aacc4adc3acc0c | 274 |
|
AscNHalf | AscNHalf | src/ascnhalf-world/WayPoints.cpp | ChatHandler::HandleWPChangeNoCommand |
bool ChatHandler::HandleWPChangeNoCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT)
{
SystemMessage(m_session, "You should select a Waypoint.");
return true;
}
Player* pPlayer = m_session->GetPlayer();
AIInterface* ai = pPlayer->waypointunit;
if(!ai || !ai->GetUnit())
{
SystemMessage(m_session, "Invalid Creature, please select another one.");
return true;
}
std::stringstream ss;
char* pNewID = strtok((char*)args, " ");
uint32 NewID = (pNewID)? atoi(pNewID) : 0;
uint32 wpid = GUID_LOPART(guid);
if(NewID == wpid) return false;
if(wpid)
{
bool show = ai->m_WayPointsShowing;
if(show == true)
ai->hideWayPoints(pPlayer);
ai->changeWayPointID(wpid,NewID);
if(show == true)
ai->showWayPoints(pPlayer,ai->m_WayPointsShowBackwards);
ss << "Waypoint " << wpid << " changed to Waypoint " << NewID << ".";
SystemMessage(m_session, ss.str().c_str());
}
else
{
SystemMessage(m_session, "Invalid Waypoint.");
return true;
}
return true;
} |
bool ChatHandler::HandleWPAddCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPMoveTypeCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPShowCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPDeleteCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPFlagsCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPMoveHereCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPWaitCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWaypointGettextCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWaypointForwardTextCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWaypointBackwardTextCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPSpellToCastCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPStandStateCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPEmoteCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPSkinCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPInfoCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleWPHideCommand(const char* args, WorldSession *m_session);
bool ChatHandler::HandleGenerateWaypoints(const char* args, WorldSession * m_session);
bool ChatHandler::HandleSaveWaypoints(const char* args, WorldSession * m_session);
bool ChatHandler::HandleDeleteWaypoints(const char* args, WorldSession * m_session);
bool ChatHandler::HandleWaypointAddFlyCommand(const char * args, WorldSession * m_session);
bool ChatHandler::HandleNpcSelectCommand(const char * args, WorldSession * m_session);
| 9405b7bd9d2e6f9bac04c9fec0666df3bd521cbbb21ea8dfcc09af60a966a32b | 1,253 |
|
BlazesRus | niflib | src/obj/NiBinaryExtraData.cpp | NiBinaryExtraData::Write |
void NiBinaryExtraData::Write(ostream& out, const map<NiObjectRef, unsigned int> & link_map, list<NiObject *> & missing_link_stack, const NifInfo & info) const
{
NiExtraData::Write(out, link_map, missing_link_stack, info);
binaryData.dataSize = (unsigned int) (binaryData.data.size());
NifStream(binaryData.dataSize, out, info);
for(unsigned int i1 = 0; i1 < binaryData.data.size(); i1++)
{
NifStream(binaryData.data[i1], out, info);
};
} |
NiBinaryExtraData::NiBinaryExtraData();
NiBinaryExtraData::~NiBinaryExtraData();
const Type & NiBinaryExtraData::GetType();
NiObject * NiBinaryExtraData::Create();
void NiBinaryExtraData::Read(istream& in, list<unsigned int> & link_stack, const NifInfo & info);
std::string NiBinaryExtraData::asString(bool verbose);
void NiBinaryExtraData::FixLinks(const map<unsigned int, NiObjectRef> & objects, list<unsigned int> & link_stack, list<NiObjectRef> & missing_link_stack, const NifInfo & info);
std::list<NiObjectRef> NiBinaryExtraData::GetRefs();
std::list<NiObject *> NiBinaryExtraData::GetPtrs();
vector<byte> NiBinaryExtraData::GetData();
void NiBinaryExtraData::SetData(const vector<byte> & n);
| a83c60bb7e85de4f1ad6432b2a04f345a1447a68b73820a2db0d9e1461f557cc | 461 |
|
CarlosManuelRodr | wxChaos | libs/wxMSW-3.1.4/src/gtk/renderer.cpp |
int
wxRendererGTK::DrawHeaderButton |
int
wxRendererGTK::DrawHeaderButton(wxWindow *win,
wxDC& dc,
const wxRect& rect,
int flags,
wxHeaderSortIconType sortArrow,
wxHeaderButtonParams* params)
{
GtkWidget *button = wxGTKPrivate::GetHeaderButtonWidget();
if (flags & wxCONTROL_SPECIAL)
button = wxGTKPrivate::GetHeaderButtonWidgetFirst();
if (flags & wxCONTROL_DIRTY)
button = wxGTKPrivate::GetHeaderButtonWidgetLast();
int x_diff = 0;
if (win->GetLayoutDirection() == wxLayout_RightToLeft)
x_diff = rect.width;
GtkStateType state = GTK_STATE_NORMAL;
if (flags & wxCONTROL_DISABLED)
state = GTK_STATE_INSENSITIVE;
else
{
if (flags & wxCONTROL_CURRENT)
state = GTK_STATE_PRELIGHT;
}
#ifdef __WXGTK3__
cairo_t* cr = wxGetGTKDrawable(dc);
if (cr == NULL)
return 0;
#if GTK_CHECK_VERSION(3,20,0)
if (gtk_check_version(3,20,0) == NULL)
{
int pos = 1;
if (flags & wxCONTROL_SPECIAL)
pos = 0;
if (flags & wxCONTROL_DIRTY)
pos = 2;
wxGtkStyleContext sc(dc.GetContentScaleFactor());
sc.AddTreeviewHeaderButton(pos);
gtk_style_context_set_state(sc, stateTypeToFlags[state]);
gtk_render_background(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height);
gtk_render_frame(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height);
}
else
#endif
{
GtkStyleContext* sc = gtk_widget_get_style_context(button);
gtk_style_context_save(sc);
gtk_style_context_set_state(sc, stateTypeToFlags[state]);
gtk_render_background(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height);
gtk_render_frame(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height);
gtk_style_context_restore(sc);
}
#else
GdkWindow* gdk_window = wxGetGTKDrawable(dc);
gtk_paint_box
(
gtk_widget_get_style(button),
gdk_window,
state,
GTK_SHADOW_OUT,
NULL,
button,
"button",
dc.LogicalToDeviceX(rect.x) - x_diff, rect.y, rect.width, rect.height
);
#endif
return DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params);
} |
wxRendererNative& wxRendererNative::GetDefault();
static cairo_t* wxGetGTKDrawable(const wxDC& dc);
static GdkWindow* wxGetGTKDrawable(wxDC& dc);
int wxRendererGTK::GetHeaderButtonHeight(wxWindow *WXUNUSED(win);
int wxRendererGTK::GetHeaderButtonMargin(wxWindow *WXUNUSED(win);
static int GetGtkSplitterFullSize(GtkWidget* widget);
CheckBoxInfo(wxGtkStyleContext& sc, int flags);
CheckBoxInfo(GtkWidget* button, int flags);
void FitInto(const wxRect& rect);
void wxRendererGTK::DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags);
void wxRendererGTK::DrawTextCtrl(wxWindow*, wxDC& dc, const wxRect& rect, int flags);
void wxRendererGTK::DrawComboBox(wxWindow* win, wxDC& dc, const wxRect& rect, int flags);
void wxRendererGTK::DrawRadioBitmap(wxWindow*, wxDC& dc, const wxRect& rect, int flags);
| fe81bf43efa890075ea4bea05890265cedf12df61cf787484589a7b84d1eb8ba | 2,374 |
|
BrandonSchaefer | xbmc | xbmc/network/test/TestWebServer.cpp |
TEST_F |
TEST_F(TestWebServer, CanGetRangedFileRangeFirst_Second)
{
const std::string rangedFileContent = TEST_FILES_DATA_RANGES;
std::vector<std::string> rangedContent = StringUtils::Split(TEST_FILES_DATA_RANGES, ";");
const std::string range = GenerateRangeHeaderValue(rangedContent.front().size() + 1, rangedContent.front().size() + 1 + rangedContent.at(2).size() - 1);
CHttpRanges ranges;
ASSERT_TRUE(ranges.Parse(range, rangedFileContent.size()));
std::string result;
CCurlFile curl;
curl.SetRequestHeader(MHD_HTTP_HEADER_RANGE, range);
ASSERT_TRUE(curl.Get(GetUrlOfTestFile(TEST_FILES_RANGES), result));
CheckRangesTestFileResponse(curl, result, ranges);
} | TestWebServer();
virtual void SetUp();
virtual void TearDown();
void SetupMediaSources();
void TearDownMediaSources();
std::string GetUrl(const std::string& path);
std::string GetUrlOfTestFile(const std::string& testFile);
bool GetLastModifiedOfTestFile(const std::string& testFile, CDateTime& lastModified);
void CheckHtmlTestFileResponse(const CCurlFile& curl);
void CheckRangesTestFileResponse(const CCurlFile& curl, int httpStatus = MHD_HTTP_OK, bool empty = false);
void CheckRangesTestFileResponse(const CCurlFile& curl, const std::string& result, const CHttpRanges& ranges);
std::string GenerateRangeHeaderValue(unsigned int start, unsigned int end);
TEST_F(TestWebServer, IsStarted);
TEST_F(TestWebServer, CanGetJsonRpcApiDescription);
TEST_F(TestWebServer, CanGetJsonRpcResponse);
TEST_F(TestWebServer, CanNotHeadNonExistingFile);
TEST_F(TestWebServer, CanHeadFile);
TEST_F(TestWebServer, CanNotGetNonExistingFile);
TEST_F(TestWebServer, CanGetFile);
TEST_F(TestWebServer, CanGetFileForcingNoCache);
TEST_F(TestWebServer, CanGetCachedFileWithOlderIfModifiedSince);
TEST_F(TestWebServer, CanGetCachedFileWithNewerIfModifiedSinceForcingNoCache);
TEST_F(TestWebServer, CanGetCachedFileWithOlderIfUnmodifiedSince);
TEST_F(TestWebServer, CanGetCachedFileWithExactIfUnmodifiedSince);
TEST_F(TestWebServer, CanGetCachedFileWithNewerIfUnmodifiedSince);
TEST_F(TestWebServer, CanGetRangedFileRange0_);
TEST_F(TestWebServer, CanGetRangedFileRange0_End);
TEST_F(TestWebServer, CanGetRangedFileRange0_2xEnd);
TEST_F(TestWebServer, CanGetRangedFileRange0_First);
TEST_F(TestWebServer, CanGetRangedFileRange_Last);
TEST_F(TestWebServer, CanGetRangedFileRangeFirstSecond);
TEST_F(TestWebServer, CanGetRangedFileRangeFirstSecondLast);
TEST_F(TestWebServer, CanGetCachedRangedFileWithOlderIfRange);
TEST_F(TestWebServer, CanGetCachedRangedFileWithExactIfRange);
TEST_F(TestWebServer, CanGetCachedRangedFileWithNewerIfRange);
| 7dd49d51aab5b1fe2e2a27217a2b5e07d0696e01a639d3b34480709c3361a09a | 680 |
|
vldtecno | PTN-Engine | Examples/Elevator/Controller/ElevatorController.cpp | ElevatorController::increaseFloor | void ElevatorController::increaseFloor()
{
cout << "Ascending... " << endl;
++m_currentFloor;
printCurrentFloor();
}
| ElevatorController::ElevatorController();
ElevatorController::~ElevatorController();
void ElevatorController::initialize();
void ElevatorController::openDoors();
void ElevatorController::closeDoors();
bool ElevatorController::callElevatorUp(const int floor);
bool ElevatorController::callElevatorDown(const int floor);
bool ElevatorController::setDestinationFloor(const int floor);
void ElevatorController::addDestination1();
void ElevatorController::addDestination2();
void ElevatorController::addWaitingToGoDown();
void ElevatorController::addWaitingToGoUp();
void ElevatorController::removeDestinationGU();
void ElevatorController::removeDestinationGD();
void ElevatorController::removeDestination();
void ElevatorController::removeCurrentFromWaitingToGoDown();
void ElevatorController::removeCurrentFromWaitingToGoUp();
void ElevatorController::rotateLists();
void ElevatorController::decreaseFloor();
void ElevatorController::mergeGoingUpGTCurrent();
void ElevatorController::mergeMinGoingUp();
void ElevatorController::mergeMaxGoingDown();
void ElevatorController::mergePostponedToCurrent();
void ElevatorController::mergeGoingDownSTCurrent();
void ElevatorController::mergeToDestinations(unordered_set<int>& toAdd, const bool lessThan);
void ElevatorController::processedLists();
bool ElevatorController::isFloorNotInList();
bool ElevatorController::isFloorInList();
bool ElevatorController::isDestinationListNotEmpty();
bool ElevatorController::isDestinationListEmpty();
bool ElevatorController::isMarkedFloorNotCurrentFloor();
bool ElevatorController::isMarkedFloorGreaterThanCurrentFloor();
bool ElevatorController::isMarkedFloorSmallerThanCurrentFloor();
bool ElevatorController::isMinSmallerThanCurrent();
bool ElevatorController::isMinGreaterThanCurrent();
bool ElevatorController::isMaxSmallerThanCurrent();
bool ElevatorController::isMaxGreaterThanCurrent();
void ElevatorController::elevatorStopped();
void ElevatorController::elevatorMoving();
void ElevatorController::doorsAreOpen();
void ElevatorController::doorsAreClosed();
void ElevatorController::goingUp();
void ElevatorController::goingDown();
void ElevatorController::printCurrentFloor();
void ElevatorController::printDestinations();
void ElevatorController::printNextDestinations();
void ElevatorController::printWaitingGoDown();
void ElevatorController::printWaitingGoUp();
void ElevatorController::printFloorList(const unordered_set<int>& floors);
void ElevatorController::printSchedule();
| e91d179f1934b6cd8762b0208925e348b998e94d143bfdae48c212be1e431cf9 | 120 |
|
OxfordSKA | OSKAR | oskar/settings/types/src/oskar_IntListExt.cpp | IntListExt::init |
bool IntListExt::init(const char* s)
{
if (!s || strlen(s) == 0) return false;
special_value_ = string(s);
default_ = special_value_;
value_ = special_value_;
return true;
} |
static bool compare(const IntListExt::Value& a, const IntListExt::Value& b);
IntListExt::IntListExt();
IntListExt::~IntListExt();
bool IntListExt::set_default(const char* value);
bool IntListExt::set_value(const char* value);
bool IntListExt::is_default();
const char* IntListExt::special_string();
bool IntListExt::is_extended();
int IntListExt::size();
const int* IntListExt::values();
bool IntListExt::operator==(const IntListExt& other);
bool IntListExt::operator>(const IntListExt&);
bool IntListExt::from_string(const string& s, Value& val);
string IntListExt::to_string(const Value& v);
| 54504b90a6022952b8cd38b7f24b7a519c2a44431d5d8ce23e9018a0d4b0dba1 | 194 |
|
mohsenti | DSPlayer | 3rdParties/mediainfo/MediaInfoLib/Source/MediaInfo/Video/File_Vc3.cpp | File_Vc3::Synched_Test | bool File_Vc3::Synched_Test() {
if (Buffer_Offset + 5 > Buffer_Size)
return false;
if (Buffer[Buffer_Offset] != 0x00
|| Buffer[Buffer_Offset + 1] != 0x00
|| Buffer[Buffer_Offset + 2] != 0x02
|| Buffer[Buffer_Offset + 3] != 0x80
|| Buffer[Buffer_Offset + 4] == 0x00) {
Synched = false;
return true;
}
return true;
} | static const bool Vc3_FromCID_IsSupported(int32u CompressionID);
static const int32u Vc3_CompressedFrameSize(int32u CompressionID);
static const int8u Vc3_SBD(int32u SBD);
static const int8u Vc3_SBD_FromCID(int32u CompressionID);
static const char *Vc3_SST_FromCID(int32u CompressionID);
static const int16u Vc3_SPL_FromCID(int32u CompressionID);
static const int16u Vc3_ALPF_PerFrame_FromCID(int32u CompressionID);
static const char *Vc3_CLR_FromCID(int32u CompressionID);
static const char *Vc3_SSC_FromCID(int32u CompressionID);
File_Vc3::File_Vc3();
File_Vc3::~File_Vc3();
void File_Vc3::Streams_Fill();
void File_Vc3::Streams_Finish();
bool File_Vc3::Synchronize();
bool File_Vc3::Demux_UnpacketizeContainer_Test();
void File_Vc3::Read_Buffer_Unsynched();
bool File_Vc3::Header_Begin();
void File_Vc3::Header_Parse();
void File_Vc3::Data_Parse();
void File_Vc3::HeaderPrefix();
void File_Vc3::CodingControlA();
void File_Vc3::ImageGeometry();
void File_Vc3::CompressionID();
void File_Vc3::CodingControlB();
void File_Vc3::TimeCode();
void File_Vc3::UserData();
void File_Vc3::UserData_8();
| dc4eabdbaa24fc56eba85dd98c2712537cbd4fb24a2eae49dacd7e9067fabcf5 | 467 |
|
nielsbasjes | SuckMT | nt.cpp |
void
omni_thread::start |
void
omni_thread::start(void)
{
omni_mutex_lock l(mutex);
if (_state != STATE_NEW)
throw omni_thread_invalid();
#ifndef __BCPLUSPLUS__
unsigned int t;
handle = (HANDLE)_beginthreadex(
NULL,
0,
omni_thread_wrapper,
(LPVOID)this,
CREATE_SUSPENDED,
&t);
nt_id = t;
if (handle == NULL)
throw omni_thread_fatal(GetLastError());
#else
handle = (HANDLE)_beginthreadNT(omni_thread_wrapper,
0,
(void*)this,
NULL,
CREATE_SUSPENDED,
&nt_id);
if (handle == INVALID_HANDLE_VALUE)
throw omni_thread_fatal(errno);
#endif
if (!SetThreadPriority(handle, nt_priority(_priority)))
throw omni_thread_fatal(GetLastError());
if (ResumeThread(handle) == 0xffffffff)
throw omni_thread_fatal(GetLastError());
_state = STATE_RUNNING;
} |
omni_mutex::omni_mutex(void);
omni_mutex::~omni_mutex(void);
inline _internal_omni_thread_helper();
inline ~_internal_omni_thread_helper();
omni_condition::omni_condition(omni_mutex* m);
omni_condition::~omni_condition(void);
omni_semaphore::omni_semaphore(unsigned int initial);
omni_semaphore::~omni_semaphore(void);
omni_thread::init_t::init_t(void);
omni_thread_wrapper(void* ptr);
omni_thread::omni_thread(void (*fn);
omni_thread::omni_thread(void* (*fn);
omni_thread::omni_thread(void* arg, priority_t pri);
omni_thread::~omni_thread(void);
| fc62c324ed717dc390a7f40943ef07e7d2f38e1bb2c48c61ddeac7a5b1ae60b4 | 982 |
|
soulik | LuaBox2D | src/objects/RevoluteJoint.cpp | RevoluteJoint::getUserData | inline int RevoluteJoint::getUserData(State & state, b2RevoluteJoint * object){
return base->getUserData(state, object);
} | void initRevoluteJoint(State * state);
b2RevoluteJoint * RevoluteJoint::constructor(State & state, bool & managed);
void RevoluteJoint::destructor(State & state, b2RevoluteJoint * object);
inline int RevoluteJoint::getType(State & state, b2RevoluteJoint * object);
inline int RevoluteJoint::getBodyA(State & state, b2RevoluteJoint * object);
inline int RevoluteJoint::getBodyB(State & state, b2RevoluteJoint * object);
inline int RevoluteJoint::setUserData(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getAnchorA(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getAnchorB(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getReactionForce(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getReactionTorque(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getMotorTorque(State & state, b2RevoluteJoint * object);
inline int RevoluteJoint::getActive(State & state, b2RevoluteJoint * object);
inline int RevoluteJoint::getCollideConnected(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getLocalAnchorA(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getLocalAnchorB(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getReferenceAngle(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getEnableLimit(State & state, b2RevoluteJoint * object);
int RevoluteJoint::setEnableLimit(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getLowerLimit(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getUpperLimit(State & state, b2RevoluteJoint * object);
int RevoluteJoint::setLimits(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getEnableMotor(State & state, b2RevoluteJoint * object);
int RevoluteJoint::setEnableMotor(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getMotorSpeed(State & state, b2RevoluteJoint * object);
int RevoluteJoint::setMotorSpeed(State & state, b2RevoluteJoint * object);
int RevoluteJoint::getMaxMotorTorque(State & state, b2RevoluteJoint * object);
int RevoluteJoint::setMaxMotorTorque(State & state, b2RevoluteJoint * object);
| a66576436327067860b3ec77b37676d69474d9336ccfaf87410c43c6b27fbb4a | 126 |
|
plewis | phycas | src/cpp/partition_model.cpp | PartitionModel::getSubsetProportions |
SubsetProportionsShPtr PartitionModel::getSubsetProportions()
{
return _subset_proportions;
} |
PartitionModel::PartitionModel();
PartitionModel::~PartitionModel();
void PartitionModel::createJointPriorManager();
unsigned PartitionModel::getNumSubsets();
unsigned PartitionModel::getTotalNumPatterns();
unsigned PartitionModel::getTotalNumSites();
const ModelVect & PartitionModel::getModelsVect();
double PartitionModel::getSubsetRelRate(unsigned i);
const std::vector<double> & PartitionModel::getSubsetRelRatesVect();
MultivarProbDistShPtr PartitionModel::getSubsetRelRatePrior();
void PartitionModel::debugShowTransformedRelativeRates(const std::string msg);
const std::vector<unsigned> & PartitionModel::getNumPatternsVect();
unsigned PartitionModel::getNumSites(unsigned i);
const std::vector<unsigned> & PartitionModel::getNumSitesVect();
const std::vector<unsigned> & PartitionModel::getNumStatesVect();
const std::vector<unsigned> & PartitionModel::getNumRatesVect();
void PartitionModel::addModel(ModelShPtr m);
void PartitionModel::setModelsVect(const ModelVect & models);
void PartitionModel::setNumPatternsVect(const std::vector<unsigned> & npatterns);
void PartitionModel::setNumSitesVect(const std::vector<unsigned> & nsites);
void PartitionModel::setNumStatesVect(const std::vector<unsigned> & nstates);
void PartitionModel::setNumRatesVect(const std::vector<unsigned> & nrates);
void PartitionModel::setSiteAssignments(const std::vector<unsigned> & v);
const std::vector<unsigned> & PartitionModel::getSiteAssignments();
unsigned PartitionModel::getNumFreeParameters();
std::vector<std::string> PartitionModel::getPWKParameterNames();
std::vector<std::string> PartitionModel::getFreeParameterNames();
std::vector<std::string> PartitionModel::getAllParameterNames();
void PartitionModel::appendUntransformedSubsetRelativeRates(std::vector<double> & values);
void PartitionModel::appendTransformedSubsetRelativeRates(std::vector<double> & values);
double PartitionModel::calcLogDetJacobian();
std::vector<double> PartitionModel::getUntransformedParameters();
std::vector<double> PartitionModel::getTransformedParameters();
double PartitionModel::getLogDetJacobian();
JointPriorManagerShPtr PartitionModel::getJointPriorManager();
| 9c38c9f840957855cc87a5c77f61113ffd7b8580b94883398fc62df64f8b9d71 | 100 |
|
Zuppka | RLG | src/modules/fileman.cpp | makeDir |
bool makeDir(std::string path) {
struct stat info;
if (stat (path.c_str(), &info) != 0) {
printf("Creating directory \"%s\"...\n", path.c_str());
CreateDirectory(path.c_str(), NULL);
return true;
}
return false;
} |
bool makeFile(std::string name);
bool Fileman::readFile(std::string path);
bool Fileman::writeFile(std::string path);
| fba4592901de84b1b47785d20b49e26dec420cc7a68ce94aac4a78a14ff5af5f | 261 |
|
bloomberg | bde | groups/bsl/bslalg/bslalg_nothrowmovableutil.t.cpp | SomeType | SomeType(int v = 0)
: d_value(v)
{
} |
void aSsErT(bool condition, const char *message, int line);
TrackableValue(int v = 0);
TrackableValue(const TrackableValue& original);
TrackableValue(bslmf::MovableRef<TrackableValue> original);
TrackableValue& operator=(int v);
TrackableValue& operator=(const TrackableValue& rhs);
void resetMoveCopiedFlags();
void TrackableValue::swap(TrackableValue& other);
void TrackableValue::setIsCopiedRaw(bool copiedFlag);
void TrackableValue::setIsMovedRaw(bool movedFlag);
void TrackableValue::setValueRaw(int v);
explicit TrackableValueWithAlloc(int v = 0);
explicit TrackableValueWithAlloc(const allocator_type& alloc);
TrackableValueWithAlloc(int v, const allocator_type& alloc);
TrackableValueWithAlloc(
bslmf::MovableRef<TrackableValueWithAlloc> original);
TrackableValueWithAlloc& operator=(const TrackableValueWithAlloc& rhs);
TrackableValueWithAlloc& operator=(
bslmf::MovableRef<TrackableValueWithAlloc> rhs);
void resetMoveCopiedFlags();
CountedType<TYPE>::CountedType(const TYPE& val);
CountedType<TYPE>::CountedType(const CountedType& original);
CountedType<TYPE>::CountedType(bslmf::MovableRef<CountedType> original);
SomeType(const SomeType& original);
SomeType(bslmf::MovableRef<SomeType> original);
CountedType2(const TYPE& val);
CountedType2(const CountedType2& original);
CountedType2(bslmf::MovableRef<CountedType2> original);
ValueType& value();
const ValueType& value();
void usageExample();
bool checkAllocator(const TYPE& obj, const bsl::allocator<char>& allocator);
bool hasSameAllocator(const TYPE& obj1, const TYPE& obj2);
void TestDriver<TYPE>::testCase4();
void TestDriver<TYPE>::testCase3();
int main(int argc, char *argv[]);
| fc95ac11093794636a766021680f133e13a7a36f33ef81c3cdeead06edf2bd22 | 49 |
|
ibrarahmad | cstore | src/UnitTests/DVTest.cpp | DVTest::runTestCase4 |
bool DVTest::runTestCase4(Globals* g, const vector<string>& args)
{
bool success = true;
WOSManager* wm = new WOSManager(DVTEST_PROJECTION_NAME,
2,
1 );
wm->deleteTuple( 5, true );
wm->deleteTuple( 4, true );
wm->deleteTuple( 100, true );
wm->deleteTuple( 99, true );
wm->deleteTuple( 88, true );
wm->deleteTuple( 12, true );
wm->deleteTuple( 50, true );
IntDataSource *ds1 = new IntDataSource( wm->getDVAM( true ),
true,
false);
Operator* srcs[1]={ ds1 };
int numCols[1]={1};
system ("rm DVTest_ROS.out");
BlockPrinter* bPrint = new BlockPrinter(srcs,
numCols,
1,
"DVTest_ROS.out");
bPrint->printColumnsWithPosition();
delete bPrint;
delete wm;
return success;
} |
DVTest::DVTest();
DVTest::~DVTest();
bool DVTest::run(Globals* g, const vector<string>& args);
bool DVTest::runTestCase1(Globals* g, const vector<string>& args);
bool DVTest::runTestCase2(Globals* g, const vector<string>& args);
bool DVTest::runTestCase3(Globals* g, const vector<string>& args);
void DVTest::makeData(Globals* g, const vector<string>& args);
| 0e7afe438fa01f841487d1cf6b993fe06dbcb4d0623e203a4f70cb5f91193def | 903 |
|
PGer | incubator-hawq | depends/libyarn/src/rpc/RpcChannel.cpp | RpcChannelImpl::cleanupPendingCalls |
void RpcChannelImpl::cleanupPendingCalls(exception_ptr reason) {
assert(!writeMut.try_lock());
unordered_map<int32_t, RpcRemoteCallPtr>::iterator s, e;
e = pendingCalls.end();
for (s = pendingCalls.begin(); s != e; ++s) {
s->second->cancel(reason);
}
pendingCalls.clear();
} |
RpcChannelImpl::RpcChannelImpl(const RpcChannelKey & k, RpcClient & c);
RpcChannelImpl::~RpcChannelImpl();
void RpcChannelImpl::close(bool immediate);
void RpcChannelImpl::sendSaslMessage(hadoop::common::RpcSaslProto * msg, Message * resp);
std::string RpcChannelImpl::saslEvaluateToken(hadoop::common::RpcSaslProto & response, bool serverIsDone);
RpcAuth RpcChannelImpl::setupSaslConnection();
void RpcChannelImpl::connect();
exception_ptr RpcChannelImpl::invokeInternal(RpcRemoteCallPtr remote);
void RpcChannelImpl::invoke(const RpcCall & call);
void RpcChannelImpl::shutdown(exception_ptr reason);
void RpcChannelImpl::wakeupOneCaller(int32_t id);
void RpcChannelImpl::sendRequest(RpcRemoteCallPtr remote);
void RpcChannelImpl::checkOneResponse();
void RpcChannelImpl::sendPing();
bool RpcChannelImpl::checkIdle();
void RpcChannelImpl::waitForExit();
void RpcChannelImpl::sendConnectionHeader(const RpcAuth &auth);
void RpcChannelImpl::sendConnectionContent(const RpcAuth & auth);
RpcRemoteCallPtr RpcChannelImpl::getPendingCall(int32_t id);
bool RpcChannelImpl::getResponse();
static exception_ptr HandlerRpcResponseException(exception_ptr e);
void RpcChannelImpl::readOneResponse(bool writeLock);
| 3493d5ef5cc3942214594ed92e3ec34e6a4d2f33c9c6c4930a7c5aa1ac750d5d | 309 |
|
reboot | obs-studio | UI/volume-control.cpp | VolumeMeter::setMajorTickColor |
void VolumeMeter::setMajorTickColor(QColor c)
{
majorTickColor = c;
} |
void VolControl::OBSVolumeChanged(void *data, float db);
void VolControl::OBSVolumeMuted(void *data, calldata_t *calldata);
void VolControl::VolumeChanged();
void VolControl::VolumeMuted(bool muted);
void VolControl::SetMuted(bool checked);
void VolControl::SliderChanged(int vol);
void VolControl::updateText();
QString VolControl::GetName();
void VolControl::SetName(const QString &newName);
void VolControl::EmitConfigClicked();
void VolControl::SetMeterDecayRate(qreal q);
VolControl::VolControl(OBSSource source_, bool showConfig);
VolControl::~VolControl();
QColor VolumeMeter::getBackgroundNominalColor();
void VolumeMeter::setBackgroundNominalColor(QColor c);
QColor VolumeMeter::getBackgroundWarningColor();
void VolumeMeter::setBackgroundWarningColor(QColor c);
QColor VolumeMeter::getBackgroundErrorColor();
void VolumeMeter::setBackgroundErrorColor(QColor c);
QColor VolumeMeter::getForegroundNominalColor();
void VolumeMeter::setForegroundNominalColor(QColor c);
QColor VolumeMeter::getForegroundWarningColor();
void VolumeMeter::setForegroundWarningColor(QColor c);
QColor VolumeMeter::getForegroundErrorColor();
void VolumeMeter::setForegroundErrorColor(QColor c);
QColor VolumeMeter::getClipColor();
void VolumeMeter::setClipColor(QColor c);
QColor VolumeMeter::getMagnitudeColor();
void VolumeMeter::setMagnitudeColor(QColor c);
QColor VolumeMeter::getMajorTickColor();
QColor VolumeMeter::getMinorTickColor();
void VolumeMeter::setMinorTickColor(QColor c);
qreal VolumeMeter::getMinimumLevel();
void VolumeMeter::setMinimumLevel(qreal v);
qreal VolumeMeter::getWarningLevel();
void VolumeMeter::setWarningLevel(qreal v);
qreal VolumeMeter::getErrorLevel();
void VolumeMeter::setErrorLevel(qreal v);
qreal VolumeMeter::getClipLevel();
void VolumeMeter::setClipLevel(qreal v);
qreal VolumeMeter::getMinimumInputLevel();
void VolumeMeter::setMinimumInputLevel(qreal v);
qreal VolumeMeter::getPeakDecayRate();
void VolumeMeter::setPeakDecayRate(qreal v);
qreal VolumeMeter::getMagnitudeIntegrationTime();
void VolumeMeter::setMagnitudeIntegrationTime(qreal v);
qreal VolumeMeter::getPeakHoldDuration();
void VolumeMeter::setPeakHoldDuration(qreal v);
qreal VolumeMeter::getInputPeakHoldDuration();
void VolumeMeter::setInputPeakHoldDuration(qreal v);
VolumeMeter::VolumeMeter(QWidget *parent, obs_volmeter_t *obs_volmeter);
VolumeMeter::~VolumeMeter();
inline void VolumeMeter::resetLevels();
inline void VolumeMeter::handleChannelCofigurationChange();
inline bool VolumeMeter::detectIdle(uint64_t ts);
void VolumeMeter::paintEvent(QPaintEvent *event);
void VolumeMeterTimer::AddVolControl(VolumeMeter *meter);
void VolumeMeterTimer::RemoveVolControl(VolumeMeter *meter);
void VolumeMeterTimer::timerEvent(QTimerEvent*);
| dc4275751a1280a7125bde37c31635aa4f98726d4c1b4fac73ee25a48e1d2908 | 71 |
|
mworks | mworks | core/Core/ParadigmComponents/TrialBuildingBlocks.cpp | IfElse::execute |
bool IfElse::execute() {
if (conditionals.empty()) {
mwarning(M_PARADIGM_MESSAGE_DOMAIN, "if/else contains no conditional (if) actions");
}
for (auto &cond : conditionals) {
if (cond->execute()) {
return true;
}
}
if (unconditional) {
unconditional->execute();
}
return false;
} |
void Action::describeComponent(ComponentInfo &info);
Action::Action(const ParameterValueMap ¶meters);
Action::Action();
bool Action::execute();
void Action::action();
void Action::announceEntry();
void Action::setName(const std::string &_name);
ActionVariableNotification::ActionVariableNotification(shared_ptr<Action> _action);
void ActionVariableNotification::notify(const Datum& data, MWTime time);
void Assignment::describeComponent(ComponentInfo &info);
Assignment::Assignment(const ParameterValueMap ¶meters);
Assignment::Assignment(const VariablePtr &var, const VariablePtr &value);
bool Assignment::execute();
void ReportString::describeComponent(ComponentInfo &info);
ReportString::ReportString(const ParameterValueMap ¶meters);
bool ReportString::execute();
void AssertionAction::describeComponent(ComponentInfo &info);
AssertionAction::AssertionAction(const ParameterValueMap ¶meters);
bool AssertionAction::execute();
SetTimeBase::SetTimeBase(shared_ptr<TimeBase> _timebase);
bool SetTimeBase::execute();
void TimerAction::describeComponent(ComponentInfo &info);
TimerAction::TimerAction(const ParameterValueMap ¶meters);
MWTime TimerAction::getExpirationTime();
void StartTimer::describeComponent(ComponentInfo &info);
StartTimer::StartTimer(const ParameterValueMap ¶meters);
bool StartTimer::execute();
void Wait::describeComponent(ComponentInfo &info);
Wait::Wait(const ParameterValueMap ¶meters);
bool Wait::execute();
weak_ptr<State> Wait::next();
void WaitForCondition::describeComponent(ComponentInfo &info);
WaitForCondition::WaitForCondition(const ParameterValueMap ¶meters);
bool WaitForCondition::execute();
weak_ptr<State> WaitForCondition::next();
bool WaitForCondition::stillWaiting();
bool LoadStimulus::execute();
bool UnloadStimulus::execute();
bool QueueStimulus::execute();
LiveQueueStimulus::~LiveQueueStimulus();
bool LiveQueueStimulus::execute();
DequeueStimulus::DequeueStimulus(shared_ptr<StimulusNode> _stimnode);
bool DequeueStimulus::execute();
bool BringStimulusToFront::execute();
shared_ptr<StimulusNode> BringStimulusToFront::getStimulusNode();
bool SendStimulusToBack::execute();
shared_ptr<StimulusNode> SendStimulusToBack::getStimulusNode();
void StimulusDisplayAction::describeComponent(ComponentInfo &info);
StimulusDisplayAction::StimulusDisplayAction(const ParameterValueMap ¶meters);
bool StimulusDisplayAction::execute();
weak_ptr<State> StimulusDisplayAction::next();
bool StimulusDisplayAction::stillWaiting();
void UpdateStimulusDisplay::describeComponent(ComponentInfo &info);
UpdateStimulusDisplay::UpdateStimulusDisplay(const ParameterValueMap ¶meters);
boost::shared_ptr<StimulusDisplay::UpdateInfo> UpdateStimulusDisplay::performAction();
const char * UpdateStimulusDisplay::getActionName();
void ClearStimulusDisplay::describeComponent(ComponentInfo &info);
ClearStimulusDisplay::ClearStimulusDisplay(const ParameterValueMap ¶meters);
boost::shared_ptr<StimulusDisplay::UpdateInfo> ClearStimulusDisplay::performAction();
const char * ClearStimulusDisplay::getActionName();
void SoundAction::describeComponent(ComponentInfo &info);
SoundAction::SoundAction(const ParameterValueMap ¶meters);
void LoadSound::describeComponent(ComponentInfo &info);
LoadSound::LoadSound(const ParameterValueMap ¶meters);
bool LoadSound::execute();
void UnloadSound::describeComponent(ComponentInfo &info);
UnloadSound::UnloadSound(const ParameterValueMap ¶meters);
bool UnloadSound::execute();
void PlaySound::describeComponent(ComponentInfo &info);
PlaySound::PlaySound(const ParameterValueMap ¶meters);
bool PlaySound::execute();
void PauseSound::describeComponent(ComponentInfo &info);
PauseSound::PauseSound(const ParameterValueMap ¶meters);
bool PauseSound::execute();
void StopSound::describeComponent(ComponentInfo &info);
StopSound::StopSound(const ParameterValueMap ¶meters);
bool StopSound::execute();
StartDeviceIO::StartDeviceIO(shared_ptr<IODevice> _device);
bool StartDeviceIO::execute();
StopDeviceIO::StopDeviceIO(shared_ptr<IODevice> _device);
bool StopDeviceIO::execute();
void If::describeComponent(ComponentInfo &info);
If::If(const ParameterValueMap ¶meters);
If::If(const VariablePtr &condition);
void If::addAction(const boost::shared_ptr<Action> &action);
bool If::execute();
void Else::describeComponent(ComponentInfo &info);
Else::Else(const ParameterValueMap ¶meters);
bool Else::execute();
void IfElse::describeComponent(ComponentInfo &info);
IfElse::IfElse(const ParameterValueMap ¶meters);
void While::describeComponent(ComponentInfo &info);
While::While(const ParameterValueMap ¶meters);
bool While::execute();
boost::weak_ptr<State> While::next();
bool While::performIteration();
TransitionCondition::TransitionCondition(weak_ptr<State> trans);
TransitionCondition::~TransitionCondition();
weak_ptr<State> TransitionCondition::execute();
void TransitionCondition::setOwner(weak_ptr<State> _owner);
weak_ptr<State> TransitionCondition::getOwner();
weak_ptr<State> TransitionCondition::getTransition();
weak_ptr<State> TransitionIfTimerExpired::execute();
YieldToParent::YieldToParent();
YieldToParent::~YieldToParent();
weak_ptr<State> YieldToParent::execute();
void TaskSystemState::describeComponent(ComponentInfo &info);
TaskSystemState::TaskSystemState();
TaskSystemState::TaskSystemState(const ParameterValueMap ¶meters);
shared_ptr<mw::Component> TaskSystemState::createInstanceObject();
weak_ptr<State> TaskSystemState::next();
void TaskSystemState::reset();
void TaskSystemState::addTransition(shared_ptr<TransitionCondition> trans);
void TaskSystem::describeComponent(ComponentInfo &info);
TaskSystem::TaskSystem();
TaskSystem::TaskSystem(const ParameterValueMap ¶meters);
shared_ptr<mw::Component> TaskSystem::createInstanceObject();
void TaskSystem::action();
weak_ptr<State> TaskSystem::next();
void StopExperiment::describeComponent(ComponentInfo &info);
StopExperiment::StopExperiment(const ParameterValueMap ¶meters);
bool StopExperiment::execute();
void PauseExperiment::describeComponent(ComponentInfo &info);
PauseExperiment::PauseExperiment(const ParameterValueMap ¶meters);
bool PauseExperiment::execute();
void ResumeExperiment::describeComponent(ComponentInfo &info);
ResumeExperiment::ResumeExperiment(const ParameterValueMap ¶meters);
bool ResumeExperiment::execute();
bool TakeCalibrationSampleNow::execute();
StartAverageCalibrationSample::StartAverageCalibrationSample(shared_ptr<Calibrator> _calibrator);
bool StartAverageCalibrationSample::execute();
bool EndAverageAndTakeCalibrationSample::execute();
EndAverageAndIgnore::EndAverageAndIgnore(shared_ptr<Calibrator> _calibrator);
bool EndAverageAndIgnore::execute();
CalibrateNow::CalibrateNow(shared_ptr<Calibrator> _calibrator);
bool CalibrateNow::execute();
ClearCalibration::ClearCalibration(shared_ptr<Calibrator> _calibrator);
bool ClearCalibration::execute();
StartAverager::StartAverager(shared_ptr<AveragerUser> _averager);
bool StartAverager::execute();
StopAverager::StopAverager(shared_ptr<AveragerUser> _averager);
bool StopAverager::execute();
ClearAverager::ClearAverager(shared_ptr<AveragerUser> _averager);
bool ClearAverager::execute();
| 9ad393b94ca4c97b937538ececea4811cc44a46edbf55685e70aea0947288945 | 366 |
|
emoon | fs-uae | src/debug.cpp | debug_bgetpeek |
void debug_bgetpeek (uaecptr addr, uae_u32 v)
{
uae_u32 vv = v;
if (!memwatch_enabled)
return;
memwatch_func (addr, 1, 1, &vv, MW_MASK_CPU_D_R, 0);
} |
void deactivate_debugger (void);
void activate_debugger_new(void);
void activate_debugger_new_pc(uaecptr pc, int len);
bool debug_enforcer(void);
void debug_help (void);
static void mw_help(void);
static int debug_out (const TCHAR *format, ...);
uae_u32 get_byte_debug (uaecptr addr);
uae_u32 get_word_debug (uaecptr addr);
uae_u32 get_long_debug (uaecptr addr);
uae_u32 get_iword_debug (uaecptr addr);
uae_u32 get_ilong_debug (uaecptr addr);
static int safe_addr (uaecptr addr, int size);
static bool iscancel (int counter);
static bool isoperator(TCHAR **cp);
static void ignore_ws (TCHAR **c);
static TCHAR peekchar (TCHAR **c);
static TCHAR readchar (TCHAR **c);
static TCHAR next_char (TCHAR **c);
static TCHAR peek_next_char (TCHAR **c);
static int more_params (TCHAR **c);
static int readregx (TCHAR **c, uae_u32 *valp);
static bool readbinx (TCHAR **c, uae_u32 *valp);
static bool readhexx (TCHAR **c, uae_u32 *valp);
static bool readintx (TCHAR **c, uae_u32 *valp);
static int checkvaltype2 (TCHAR **c, uae_u32 *val, TCHAR def);
static int readsize (int val, TCHAR **c);
static int checkvaltype (TCHAR **cp, uae_u32 *val, int *size, TCHAR def);
static uae_u32 readnum (TCHAR **c, int *size, TCHAR def);
static uae_u32 readint (TCHAR **c);
static uae_u32 readhex (TCHAR **c);
static uae_u32 readbin (TCHAR **c);
static uae_u32 readint (TCHAR **c, int *size);
static uae_u32 readhex (TCHAR **c, int *size);
static int next_string (TCHAR **c, TCHAR *out, int max, int forceupper);
static void converter (TCHAR **c);
int notinrom (void);
static uae_u32 lastaddr (void);
static uaecptr nextaddr2 (uaecptr addr, int *next);
static uaecptr nextaddr (uaecptr addr, uaecptr last, uaecptr *end);
uaecptr dumpmem2 (uaecptr addr, TCHAR *out, int osize);
static void dumpmem (uaecptr addr, uaecptr *nxmem, int lines);
static void dump_custom_regs (int aga);
static void dump_vectors (uaecptr addr);
static void disassemble_wait (FILE *file, unsigned long insn);
void record_dma_reset (void);
void record_copper_reset (void);
STATIC_INLINE uae_u32 ledcolor (uae_u32 c, uae_u32 *rc, uae_u32 *gc, uae_u32 *bc, uae_u32 *a);
STATIC_INLINE void putpixel (uae_u8 *buf, int bpp, int x, xcolnr c8);
static void set_dbg_color(int index, uae_u8 r, uae_u8 g, uae_u8 b);
static void set_debug_colors(uae_u32 *xredcolors, uae_u32 *xgreencolors, uae_u32 *xbluescolors);
static void debug_draw_cycles (uae_u8 *buf, int bpp, int line, int width, int height, uae_u32 *xredcolors, uae_u32 *xgreencolors, uae_u32 *xbluescolors);
static void debug_draw_heatmap(uae_u8 *buf, int bpp, int line, int width, int height, uae_u32 *xredcolors, uae_u32 *xgreencolors, uae_u32 *xbluescolors);
void debug_draw(uae_u8 *buf, int bpp, int line, int width, int height, uae_u32 *xredcolors, uae_u32 *xgreencolors, uae_u32 *xbluescolors);
static void heatmap_stats(TCHAR **c);
static void free_heatmap(void);
static void init_heatmap(void);
static void memwatch_heatmap (uaecptr addr, int rwi, int size, uae_u32 accessmask);
void record_dma_event (int evt, int hpos, int vpos);
struct dma_rec *record_dma (uae_u16 reg, uae_u16 dat, uae_u32 addr, int hpos, int vpos, int type);
static void decode_dma_record (int hpos, int vpos, int toggle, bool logfile);
void log_dma_record (void);
static void init_record_copper(void);
void record_copper_blitwait (uaecptr addr, int hpos, int vpos);
void record_copper (uaecptr addr, uae_u16 word1, uae_u16 word2, int hpos, int vpos);
static struct cop_rec *find_copper_records (uaecptr addr);
static void decode_copper_insn (FILE* file, uae_u16 mword1, uae_u16 mword2, unsigned long addr);
static uaecptr decode_copperlist (FILE* file, uaecptr address, int nolines);
static int copper_debugger (TCHAR **c);
static void clearcheater(void);
static int addcheater(uaecptr addr, int size);
static void listcheater(int mode, int size);
static void deepcheatsearch (TCHAR **c);
static void cheatsearch (TCHAR **c);
static void illg_free (void);
static void illg_init (void);
static void illg_debug_check (uaecptr addr, int rwi, int size, uae_u32 val);
static void illg_debug_do (uaecptr addr, int rwi, int size, uae_u32 val);
static int debug_mem_off (uaecptr *addrp);
static void smc_free (void);
static void smc_detect_init (TCHAR **c);
static void smc_detector (uaecptr addr, int rwi, int size, uae_u32 *valp);
uae_u8 *save_debug_memwatch (int *len, uae_u8 *dstptr);
uae_u8 *restore_debug_memwatch (uae_u8 *src);
void restore_debug_memwatch_finish (void);
static int memwatch_func (uaecptr addr, int rwi, int size, uae_u32 *valp, uae_u32 accessmask, uae_u32 reg);
static uae_u32 REGPARAM2 mmu_lget (uaecptr addr);
static uae_u32 REGPARAM2 mmu_wget (uaecptr addr);
static uae_u32 REGPARAM2 mmu_bget (uaecptr addr);
static void REGPARAM2 mmu_lput (uaecptr addr, uae_u32 v);
static void REGPARAM2 mmu_wput (uaecptr addr, uae_u32 v);
static void REGPARAM2 mmu_bput (uaecptr addr, uae_u32 v);
static uae_u32 REGPARAM2 debug_lget (uaecptr addr);
static uae_u32 REGPARAM2 mmu_lgeti (uaecptr addr);
static uae_u32 REGPARAM2 mmu_wgeti (uaecptr addr);
static uae_u32 REGPARAM2 debug_wget (uaecptr addr);
static uae_u32 REGPARAM2 debug_bget (uaecptr addr);
static uae_u32 REGPARAM2 debug_lgeti (uaecptr addr);
static uae_u32 REGPARAM2 debug_wgeti (uaecptr addr);
static void REGPARAM2 debug_lput (uaecptr addr, uae_u32 v);
static void REGPARAM2 debug_wput (uaecptr addr, uae_u32 v);
static void REGPARAM2 debug_bput (uaecptr addr, uae_u32 v);
static int REGPARAM2 debug_check (uaecptr addr, uae_u32 size);
static uae_u8 *REGPARAM2 debug_xlate (uaecptr addr);
uae_u16 debug_wputpeekdma_chipset (uaecptr addr, uae_u32 v, uae_u32 mask, int reg);
uae_u16 debug_wputpeekdma_chipram (uaecptr addr, uae_u32 v, uae_u32 mask, int reg);
uae_u16 debug_wgetpeekdma_chipram (uaecptr addr, uae_u32 v, uae_u32 mask, int reg);
static void debug_putlpeek (uaecptr addr, uae_u32 v);
void debug_wputpeek (uaecptr addr, uae_u32 v);
void debug_bputpeek (uaecptr addr, uae_u32 v);
void debug_wgetpeek (uaecptr addr, uae_u32 v);
void debug_lgetpeek (uaecptr addr, uae_u32 v);
static void memwatch_reset (void);
static void memwatch_remap (uaecptr addr);
static void memwatch_setup (void);
static int deinitialize_memwatch (void);
static void initialize_memwatch (int mode);
int debug_bankchange (int mode);
addrbank *get_mem_bank_real(uaecptr addr);
static const TCHAR *getsizechar (int size);
void memwatch_dump2 (TCHAR *buf, int bufsize, int num);
static void memwatch_dump (int num);
static void memwatch (TCHAR **c);
static void writeintomem (TCHAR **c);
static uae_u8 *dump_xlate (uae_u32 addr);
static void memory_map_dump_3(UaeMemoryMap *map, int log);
void uae_memory_map(UaeMemoryMap *map);
static void memory_map_dump_2 (int log);
void memory_map_dump (void);
STATIC_INLINE uaecptr BPTR2APTR (uaecptr addr);
static TCHAR *BSTR2CSTR (uae_u8 *bstr);
static void print_task_info (uaecptr node, bool nonactive);
static void show_exec_tasks (void);
uaecptr get_base (const uae_char *name, int offset);
static TCHAR *getfrombstr(uaecptr pp);
static void copyromdata(uae_u8 bustype, uaecptr rom, int offset, uae_u8 *out, int size);
static void show_exec_lists (TCHAR *t);
static void breakfunc(uae_u32 v);
static int cycle_breakpoint(TCHAR **c);
int instruction_breakpoint (TCHAR **c);
static int process_breakpoint (TCHAR **c);
static void savemem (TCHAR **cc);
static void searchmem (TCHAR **cc);
static int staterecorder (TCHAR **cc);
void debugtest (enum debugtest_item di, const TCHAR *format, ...);
static void debugtest_set (TCHAR **inptr);
static void debug_sprite (TCHAR **inptr);
int debug_write_memory_16 (uaecptr addr, uae_u16 v);
int debug_write_memory_8 (uaecptr addr, uae_u8 v);
int debug_peek_memory_16 (uaecptr addr);
int debug_read_memory_16 (uaecptr addr);
int debug_read_memory_8 (uaecptr addr);
static void disk_debug (TCHAR **inptr);
static void find_ea (TCHAR **inptr);
static void m68k_modify (TCHAR **inptr);
static int parse_string(TCHAR **inptr, TCHAR *str, int max_len);
static void segtracker(TCHAR **inptr);
static void ppc_disasm(uaecptr addr, uaecptr *nextpc, int cnt);
static bool debug_line (TCHAR *input);
static void debug_1 (void);
static void addhistory (void);
static void debug_continue(void);
void debug (void);
const TCHAR *debuginfo (int mode);
void mmu_disasm (uaecptr pc, int lines);
void mmu_do_hit (void);
static void mmu_do_hit_pre (struct mmudata *md, uaecptr addr, int size, int rwi, uae_u32 v);
static int mmu_hit (uaecptr addr, int size, int rwi, uae_u32 *v);
static void mmu_free_node(struct mmunode *mn);
static void mmu_free(void);
static int getmmubank(struct mmudata *snptr, uaecptr p);
int mmu_init(int mode, uaecptr parm, uaecptr parm2);
void debug_parser (const TCHAR *cmd, TCHAR *out, uae_u32 outsize);
| 717aaeed7183c81c6b7091aa5be323c66641d5c0cc84dd292bd4019c02642385 | 155 |
|
web0316 | WOW | dep/ACE_wrappers/ace/String_Base.cpp |
ACE_String_Base<CHAR>::ACE_String_Base |
ACE_String_Base<CHAR>::ACE_String_Base (
const CHAR *s,
typename ACE_String_Base<CHAR>::size_type len,
ACE_Allocator *the_allocator,
bool release)
: allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()),
len_ (0),
buf_len_ (0),
rep_ (0),
release_ (false)
{
ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base");
this->set (s, len, release);
} |
ACE_String_Base<CHAR>::ACE_String_Base (ACE_Allocator *the_allocator);
ACE_String_Base<CHAR>::ACE_String_Base (const ACE_String_Base<CHAR> &s);
ACE_String_Base<CHAR>::~ACE_String_Base (void);
u_long
ACE_String_Base<CHAR>::hash (void);
void
ACE_String_Base<CHAR>::fast_resize (size_t len);
void
ACE_String_Base<CHAR>::clear (bool release);
ACE_String_Base<CHAR> &
ACE_String_Base<CHAR>::operator= (const CHAR *s);
ACE_String_Base<CHAR> &
ACE_String_Base<CHAR>::operator= (const ACE_String_Base<CHAR> &s);
void
ACE_String_Base<CHAR>::set (const CHAR *s, bool release);
void
ACE_String_Base<CHAR>::fast_clear (void);
CHAR *
ACE_String_Base<CHAR>::rep (void);
int
ACE_String_Base<CHAR>::compare (const ACE_String_Base<CHAR> &s);
bool
ACE_String_Base<CHAR>::operator== (const ACE_String_Base<CHAR> &s);
bool
ACE_String_Base<CHAR>::operator== (const CHAR *s);
void
ACE_String_Base<CHAR>::swap (ACE_String_Base<CHAR> & str);
ACE_String_Base<CHAR>
operator+ (const ACE_String_Base<CHAR> &s, const ACE_String_Base<CHAR> &t);
ACE_String_Base<CHAR>
operator+ (const CHAR *s, const ACE_String_Base<CHAR> &t);
ACE_String_Base<CHAR>
operator+ (const ACE_String_Base<CHAR> &s, const CHAR *t);
| 1525af44056d8d5e084f3bc11ff50f72e00274182addada9bafb5f2b30192d8d | 406 |
|
smogpill | core | src/pattern/thread/coTaskScheduler.cpp |
coTaskScheduler::~coTaskScheduler |
coTaskScheduler::~coTaskScheduler()
{
Stop();
for (auto* w : workers)
delete w;
} |
coTaskScheduler::coTaskScheduler(coUint nbWorkers);
void coTaskScheduler::Add(coTask& task);
void coTaskScheduler::_ExecuteOneTask(const coTaskContext& context);
void coTaskScheduler::OnStop();
coResult coTaskScheduler::OnStart();
| 191f9b3d051cff5ff8934eff61d56288361b92a64cf881132a8a0fdef6026e13 | 86 |
|
Fiware | data.Orion | src/lib/jsonParse/jsonUpdateContextRequest.cpp | metadataName |
static std::string metadataName(const std::string& path, const std::string& value, ParseData* reqDataP)
{
LM_T(LmtParse, ("Got a metadata name: '%s'", value.c_str()));
reqDataP->upcr.contextMetadataP->name = safeValue(value);
return "OK";
} |
static std::string contextElement(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string entityIdId(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string entityIdType(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string entityIdIsPattern(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string attribute(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string attributeName(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string attributeType(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string attributeValue(const std::string& path, const std::string& value, ParseData* parseDataP);
static std::string metadata(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string metadataType(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string metadataValue(const std::string& path, const std::string& value, ParseData* reqDataP);
static std::string updateAction(const std::string& path, const std::string& value, ParseData* reqDataP);
void jsonUpcrInit(ParseData* reqDataP);
void jsonUpcrRelease(ParseData* reqDataP);
std::string jsonUpcrCheck(ParseData* reqData, ConnectionInfo* ciP);
| 10409453be714513638c53ba31d202adb84156d4efdd7b725ce374e79d03abcf | 248 |
|
prpr-man | Cevious | Cevious/Vector2.cpp |
Vector2::Vector2 |
Vector2::Vector2(const Vector2 &rhs)
{
x = rhs.x;
y = rhs.y;
} |
Vector2::Vector2(void);
Vector2::Vector2(double x,double y);
bool Vector2::operator==(const Vector2 &rhs);
bool Vector2::operator!=(const Vector2 &rhs);
Vector2 Vector2::operator*(double rhs);
Vector2& Vector2::operator*=(double rhs);
Vector2 Vector2::operator/(double rhs);
Vector2& Vector2::operator/=(double rhs);
Vector2 Vector2::operator+(const Vector2 &rhs);
Vector2& Vector2::operator+=(const Vector2 &rhs);
Vector2 Vector2::operator-(const Vector2 &rhs);
Vector2& Vector2::operator-=(const Vector2 &rhs);
Vector2 Vector2::operator+(void);
Vector2 Vector2::operator-(void);
Vector2& Vector2::normalize(void);
Vector2 Vector2::normalized(void);
double Vector2::dot(const Vector2 &rhs);
double Vector2::magnitude(void);
double Vector2::angle(const Vector2 &rhs, bool degree);
double Vector2::distance(const Vector2 &lhs, const Vector2 &rhs);
| 00c8f6468b1d47428bfe13e350b54acd2e1e052768c34732fa01cdc85828608f | 71 |
|
tkelman | utf8rewind | source/tests/suite-utf8-seek-current-backwards.cpp |
TEST |
TEST(Utf8SeekCurrentBackwards, SixBytesMultiple)
{
const char* t = "\xFD\x87\x91\x81\xB2\xB1\xFC\xBF\xB2\xBA\xB0\xA2"
"\xFC\x91\x81\x92\xA2\xA2";
EXPECT_SEEKEQ(t, 12, strlen(t), strlen(t), 0, -1, SEEK_CUR);
EXPECT_SEEKEQ(t, 6, strlen(t), strlen(t), 0, -2, SEEK_CUR);
EXPECT_SEEKEQ(t, 0, strlen(t), strlen(t), 0, -3, SEEK_CUR);
} |
TEST(Utf8SeekCurrentBackwards, OneByteSingle);
TEST(Utf8SeekCurrentBackwards, OneByteSingleFirst);
TEST(Utf8SeekCurrentBackwards, OneByteSingleLast);
TEST(Utf8SeekCurrentBackwards, OneByteSinglePastStart);
TEST(Utf8SeekCurrentBackwards, OneByteSingleInvalidContinuationByteFirst);
TEST(Utf8SeekCurrentBackwards, OneByteSingleInvalidContinuationByteLast);
TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongOneByte);
TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongTwoBytes);
TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongThreeBytes);
TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongFourBytes);
TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongFiveBytes);
TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongSixBytes);
TEST(Utf8SeekCurrentBackwards, OneByteMultiple);
TEST(Utf8SeekCurrentBackwards, OneByteMultipleContinuationBytes);
TEST(Utf8SeekCurrentBackwards, OneByteMultipleOverlong);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingle);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleFirst);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleLast);
TEST(Utf8SeekCurrentBackwards, TwoBytesSinglePastStart);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleInvalidContinuationFirstByteLower);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleInvalidContinuationFirstByteUpper);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleMissingOneByte);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongOneByte);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongTwoBytes);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongThreeBytes);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongFourBytes);
TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongFiveBytes);
TEST(Utf8SeekCurrentBackwards, TwoBytesMultiple);
TEST(Utf8SeekCurrentBackwards, TwoBytesMultipleInvalid);
TEST(Utf8SeekCurrentBackwards, TwoBytesMultipleOverlong);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingle);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleFirst);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleLast);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSinglePastStart);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleInvalidContinuationFirstByteLower);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleInvalidContinuationFirstByteUpper);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleInvalidContinuationSecondByteLower);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleInvalidContinuationSecondByteUpper);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleMissingOneByte);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleMissingTwoBytes);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleOverlongOneByte);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleOverlongTwoBytes);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleOverlongThreeBytes);
TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleOverlongFourBytes);
TEST(Utf8SeekCurrentBackwards, ThreeBytesMultiple);
TEST(Utf8SeekCurrentBackwards, ThreeBytesMultipleInvalid);
TEST(Utf8SeekCurrentBackwards, ThreeBytesMultipleOverlong);
TEST(Utf8SeekCurrentBackwards, FourBytesSingle);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleFirst);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleLast);
TEST(Utf8SeekCurrentBackwards, FourBytesSinglePastStart);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationFirstByteLower);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationFirstByteUpper);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationSecondByteLower);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationSecondByteUpper);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationThirdByteLower);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationThirdByteUpper);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleMissingOneByte);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleMissingTwoBytes);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleMissingThreeBytes);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleOverlongOneByte);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleOverlongTwoBytes);
TEST(Utf8SeekCurrentBackwards, FourBytesSingleOverlongThreeBytes);
TEST(Utf8SeekCurrentBackwards, FourBytesMultiple);
TEST(Utf8SeekCurrentBackwards, FourBytesMultipleInvalid);
TEST(Utf8SeekCurrentBackwards, FourBytesMultipleOverlong);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingle);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleFirst);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleLast);
TEST(Utf8SeekCurrentBackwards, FiveBytesSinglePastStart);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationFirstByteLower);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationFirstByteUpper);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationSecondByteLower);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationSecondByteUpper);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationThirdByteLower);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationThirdByteUpper);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationFourthByteLower);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationFourthByteUpper);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleMissingOneByte);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleMissingTwoBytes);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleMissingThreeBytes);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleMissingFourBytes);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleOverlongOneByte);
TEST(Utf8SeekCurrentBackwards, FiveBytesSingleOverlongTwoBytes);
TEST(Utf8SeekCurrentBackwards, FiveBytesMultiple);
TEST(Utf8SeekCurrentBackwards, FiveBytesMultipleInvalid);
TEST(Utf8SeekCurrentBackwards, FiveBytesMultipleOverlong);
TEST(Utf8SeekCurrentBackwards, SixBytesSingle);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleFirst);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleLast);
TEST(Utf8SeekCurrentBackwards, SixBytesSinglePastStart);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFirstByteLower);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFirstByteUpper);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationSecondByteLower);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationSecondByteUpper);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationThirdByteLower);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationThirdByteUpper);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFourthByteLower);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFourthByteUpper);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFifthByteLower);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFifthByteUpper);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingOneByte);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingTwoBytes);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingThreeBytes);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingFourBytes);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingFiveBytes);
TEST(Utf8SeekCurrentBackwards, SixBytesSingleOverlongOneByte);
TEST(Utf8SeekCurrentBackwards, SixBytesMultipleInvalid);
TEST(Utf8SeekCurrentBackwards, SixBytesMultipleOverlong);
TEST(Utf8SeekCurrentBackwards, IllegalByteSingleFirst);
TEST(Utf8SeekCurrentBackwards, IllegalByteSingleLast);
TEST(Utf8SeekCurrentBackwards, IllegalByteSinglePastStart);
TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongOneByte);
TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongTwoBytes);
TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongThreeBytes);
TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongFourBytes);
TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongFiveBytes);
TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongSixBytes);
TEST(Utf8SeekCurrentBackwards, IllegalByteMultiple);
TEST(Utf8SeekCurrentBackwards, IllegalByteMultipleOverlong);
TEST(Utf8SeekCurrentBackwards, TextPastStart);
TEST(Utf8SeekCurrentBackwards, TextAtStart);
TEST(Utf8SeekCurrentBackwards, TextFromMiddle);
TEST(Utf8SeekCurrentBackwards, TextEndsInMiddle);
| fcc5d540e0afdc21523de692297a85a5fce6ab51efca972e307b38ae17c6b4f2 | 347 |
|
Yashi100 | rhodes3.3.2 | platform/android/Rhodes/jni/src/rhodessystem.cpp | rho_nativethread_end |
RHO_GLOBAL void rho_nativethread_end(void *)
{
jvm()->DetachCurrentThread();
} |
RHO_GLOBAL void android_set_path(const rho::String& root, const rho::String& sqlite);
rho::String const &rho_root_path();
const char* rho_native_rhopath();
rho::String rho_cur_path();
static bool set_posix_environment(JNIEnv *env, jclass clsRE);
RHO_GLOBAL void android_setup(JNIEnv *env);
RHO_GLOBAL void *rho_nativethread_start();
| 8ebd3527f906868da46015951afb8b1bdd69cdfb39d4d760626901d1e1769eb8 | 83 |
|
epiqc | ScaffCC | clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp | ento::shouldRegisterDominatorsTreeDumper |
bool ento::shouldRegisterDominatorsTreeDumper(const LangOptions &LO) {
return true;
} | void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
BugReporter &BR);
void ento::registerDominatorsTreeDumper(CheckerManager &mgr);
void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
BugReporter &BR);
void ento::registerPostDominatorsTreeDumper(CheckerManager &mgr);
bool ento::shouldRegisterPostDominatorsTreeDumper(const LangOptions &LO);
void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
BugReporter &BR);
void ento::registerControlDependencyTreeDumper(CheckerManager &mgr);
bool ento::shouldRegisterControlDependencyTreeDumper(const LangOptions &LO);
void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
BugReporter &BR);
void ento::registerLiveVariablesDumper(CheckerManager &mgr);
bool ento::shouldRegisterLiveVariablesDumper(const LangOptions &LO);
void checkASTCodeBody(const Decl *D, AnalysisManager& Mgr,
BugReporter &BR);
void ento::registerLiveStatementsDumper(CheckerManager &mgr);
bool ento::shouldRegisterLiveStatementsDumper(const LangOptions &LO);
void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
BugReporter &BR);
void ento::registerCFGViewer(CheckerManager &mgr);
bool ento::shouldRegisterCFGViewer(const LangOptions &LO);
void checkASTCodeBody(const Decl *D, AnalysisManager& mgr,
BugReporter &BR);
void ento::registerCFGDumper(CheckerManager &mgr);
bool ento::shouldRegisterCFGDumper(const LangOptions &LO);
void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr,
BugReporter &BR);
void ento::registerCallGraphViewer(CheckerManager &mgr);
bool ento::shouldRegisterCallGraphViewer(const LangOptions &LO);
void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr,
BugReporter &BR);
void ento::registerCallGraphDumper(CheckerManager &mgr);
bool ento::shouldRegisterCallGraphDumper(const LangOptions &LO);
static int compareEntry(const Table::MapEntryTy *const *LHS,
const Table::MapEntryTy *const *RHS);
void ento::registerConfigDumper(CheckerManager &mgr);
bool ento::shouldRegisterConfigDumper(const LangOptions &LO);
void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,ExprEngine &Eng);
void ento::registerExplodedGraphViewer(CheckerManager &mgr);
bool ento::shouldRegisterExplodedGraphViewer(const LangOptions &LO);
void checkPreStmt(const Stmt *S, CheckerContext &C);
void ento::registerReportStmts(CheckerManager &mgr);
bool ento::shouldRegisterReportStmts(const LangOptions &LO);
| 643c477650a5ffc9364df67a7dc515f540bcfd3cf23cd3cdb09f4c475be3c75b | 88 |
|
Jiwan | x64dbg | x64_dbg_dbg/_dbgfunctions.cpp | _getaddrfromline |
static duint _getaddrfromline(const char* szSourceFile, int line)
{
LONG displacement = 0;
IMAGEHLP_LINE64 lineData;
memset(&lineData, 0, sizeof(lineData));
lineData.SizeOfStruct = sizeof(lineData);
if(!SymGetLineFromName64(fdProcessInfo->hProcess, NULL, szSourceFile, line, &displacement, &lineData))
return 0;
return (duint)lineData.Address;
} |
const DBGFUNCTIONS* dbgfunctionsget();
static bool _assembleatex(duint addr, const char* instruction, char* error, bool fillnop);
static bool _sectionfromaddr(duint addr, char* section);
static bool _patchget(duint addr);
static bool _patchinrange(duint start, duint end);
static bool _mempatch(duint va, const unsigned char* src, duint size);
static void _patchrestorerange(duint start, duint end);
static bool _patchrestore(duint addr);
static void _getcallstack(DBGCALLSTACK* callstack);
static bool _getjitauto(bool* jit_auto);
static bool _getcmdline(char* cmd_line, size_t* cbsize);
static bool _setcmdline(const char* cmd_line);
static bool _getjit(char* jit, bool jit64);
bool _getprocesslist(DBGPROCESSINFO** entries, int* count);
static void _memupdatemap();
static bool _getsourcefromaddr(duint addr, char* szSourceFile, int* line);
static bool _valfromstring(const char* string, duint* value);
void dbgfunctionsinit();
| 2474b4299d6c79719c0078e7820e1a26f4c7cba6788bc40151d0ffa254b7cea7 | 387 |
|
Try | Tempest | Engine/thirdparty/openal-soft/alc/effects/equalizer.cpp | EqualizerState::deviceUpdate |
void EqualizerState::deviceUpdate(const DeviceBase*, const Buffer&)
{
for(auto &e : mChans)
{
std::for_each(std::begin(e.filter), std::end(e.filter), std::mem_fn(&BiquadFilter::clear));
std::fill(std::begin(e.CurrentGains), std::end(e.CurrentGains), 0.0f);
}
} |
void EqualizerState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut);
EffectStateFactory *EqualizerStateFactory_getFactory();
| 2ef9389ba9eac4db6aeafbb813125f5a5f38ce9e7ac2f2ff00a15169fa94f922 | 289 |
|
harmattan | meegotouch-controlpanel | controlpanel/tests/doubles/dcpappletmanager-fake.cpp |
bool
DcpAppletManager::isMetadataPreloaded |
bool
DcpAppletManager::isMetadataPreloaded()
{
return true;
} | FakeDcpAppletManager(DcpAppletManager *mng);
~FakeDcpAppletManager();
void createTestApplet(const QString& name);
DcpAppletObject *applet(const QString &name);
DcpAppletMetadata *metadata(const QString &name);
DcpAppletMetadataList list();
DcpAppletManager::DcpAppletManager ();
DcpAppletManager::~DcpAppletManager ();
bool DcpAppletManager::isAppletLoaded (const QString&);
QList<DcpAppletObject*> DcpAppletManager::loadedApplets ();
bool DcpAppletManager::containsFile(const QString &name);
bool DcpAppletManager::containsName(const QString &name);
void DcpAppletManager::processSingleDesktopFile();
bool DcpAppletManager::mainPageAppletFound();
| 43037a5349c968bf33637aebe69b91c46ad0b3aafb9f535ae82b5bf8fcd64f41 | 66 |
|
Amara1231 | blizzlikecore | src/game/ScriptMgr.cpp | ScriptMgr::GODialogStatus |
uint32 ScriptMgr::GODialogStatus(Player* pPlayer, GameObject* pGO)
{
Script *tmpscript = m_scripts[pGO->GetGOInfo()->ScriptId];
if (!tmpscript || !tmpscript->pGODialogStatus) return 100;
pPlayer->PlayerTalkClass->ClearMenus();
return tmpscript->pGODialogStatus(pPlayer, pGO);
} |
void ScriptMgr::LoadDatabase();
ScriptMgr::ScriptMgr();
ScriptMgr::~ScriptMgr();
void ScriptMgr::ScriptsInit();
void DoScriptText(int32 iTextEntry, WorldObject* pSource, Unit* pTarget);
void Script::RegisterSelf();
void ScriptMgr::OnLogin(Player *pPlayer);
void ScriptMgr::OnLogout(Player *pPlayer);
void ScriptMgr::OnPVPKill(Player *killer, Player *killed);
char const* ScriptMgr::ScriptsVersion();
bool ScriptMgr::GossipHello (Player * pPlayer, Creature* pCreature);
bool ScriptMgr::GossipSelect(Player* pPlayer, Creature* pCreature, uint32 uiSender, uint32 uiAction);
bool ScriptMgr::GossipSelectWithCode(Player* pPlayer, Creature* pCreature, uint32 uiSender, uint32 uiAction, const char* sCode);
bool ScriptMgr::GOSelect(Player* pPlayer, GameObject* pGO, uint32 uiSender, uint32 uiAction);
bool ScriptMgr::GOSelectWithCode(Player* pPlayer, GameObject* pGO, uint32 uiSender, uint32 uiAction, const char* sCode);
bool ScriptMgr::QuestAccept(Player* pPlayer, Creature* pCreature, Quest const* pQuest);
bool ScriptMgr::QuestSelect(Player* pPlayer, Creature* pCreature, Quest const* pQuest);
bool ScriptMgr::QuestComplete(Player* pPlayer, Creature* pCreature, Quest const* pQuest);
bool ScriptMgr::ChooseReward(Player* pPlayer, Creature* pCreature, Quest const* pQuest, uint32 opt);
uint32 ScriptMgr::NPCDialogStatus(Player* pPlayer, Creature* pCreature);
bool ScriptMgr::ItemHello(Player* pPlayer, Item* pItem, Quest const* pQuest);
bool ScriptMgr::ItemQuestAccept(Player* pPlayer, Item* pItem, Quest const* pQuest);
bool ScriptMgr::GOHello(Player* pPlayer, GameObject* pGO);
bool ScriptMgr::GOQuestAccept(Player* pPlayer, GameObject* pGO, Quest const* pQuest);
bool ScriptMgr::GOChooseReward(Player* pPlayer, GameObject* pGO, Quest const* pQuest, uint32 opt);
bool ScriptMgr::AreaTrigger(Player* pPlayer, AreaTriggerEntry const* atEntry);
CreatureAI* ScriptMgr::GetAI(Creature* pCreature);
bool ScriptMgr::ItemUse(Player* pPlayer, Item* pItem, SpellCastTargets const& targets);
bool ScriptMgr::EffectDummyCreature(Unit *caster, uint32 spellId, uint32 effIndex, Creature *crTarget);
InstanceData* ScriptMgr::CreateInstanceData(Map *map);
| cf8149daafc004c73ec4f502a49acb5229b281233b2b57ad75c4df2a32efd565 | 295 |
|
devxkh | FrankE | src/Tests/TestDispatcher/main.cpp | main |
int main()
{
GrapicsManager gm;
GameThread mGameThread(&gm);
while (true)
{
std::chrono::milliseconds dura(5000);
std::this_thread::sleep_for(dura);
}
} | QueueHandler();
void AddOnSomethingHandler(OnSomethingHandler Handler);
void TriggerRenderEvents(void);
void setPosition(int val);
Entity::Entity(GrapicsManager* gmanager);
void Entity::createEntity(int id);
void Entity::setEntityPosition(int val);
GrapicsManager::GrapicsManager();
void GrapicsManager::RenderLoop();
GameThread(GrapicsManager* gmanager);
void GameLoop();
| 6acf3f9d2c2b788652dc475b7334e2991db75fda457c6ac289e4f0cacc7bdbb1 | 176 |
|
chiaming0914 | awe-cpp-sdk | aws-cpp-sdk-inspector/source/InspectorClient.cpp | InspectorClient::StartDataCollectionAsyncHelper | oid InspectorClient::StartDataCollectionAsyncHelper(const StartDataCollectionRequest& request, const StartDataCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
{
handler(this, request, StartDataCollection(request), context);
}
| nspectorClient::InspectorClient(const Client::ClientConfiguration& clientConfiguration);
nspectorClient::InspectorClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration);
nspectorClient::InspectorClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
const Client::ClientConfiguration& clientConfiguration);
nspectorClient::~InspectorClient();
oid InspectorClient::init(const ClientConfiguration& config);
ddAttributesToFindingsOutcome InspectorClient::AddAttributesToFindings(const AddAttributesToFindingsRequest& request);
ddAttributesToFindingsOutcomeCallable InspectorClient::AddAttributesToFindingsCallable(const AddAttributesToFindingsRequest& request);
oid InspectorClient::AddAttributesToFindingsAsync(const AddAttributesToFindingsRequest& request, const AddAttributesToFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::AddAttributesToFindingsAsyncHelper(const AddAttributesToFindingsRequest& request, const AddAttributesToFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
ttachAssessmentAndRulesPackageOutcome InspectorClient::AttachAssessmentAndRulesPackage(const AttachAssessmentAndRulesPackageRequest& request);
ttachAssessmentAndRulesPackageOutcomeCallable InspectorClient::AttachAssessmentAndRulesPackageCallable(const AttachAssessmentAndRulesPackageRequest& request);
oid InspectorClient::AttachAssessmentAndRulesPackageAsync(const AttachAssessmentAndRulesPackageRequest& request, const AttachAssessmentAndRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::AttachAssessmentAndRulesPackageAsyncHelper(const AttachAssessmentAndRulesPackageRequest& request, const AttachAssessmentAndRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
reateApplicationOutcome InspectorClient::CreateApplication(const CreateApplicationRequest& request);
reateApplicationOutcomeCallable InspectorClient::CreateApplicationCallable(const CreateApplicationRequest& request);
oid InspectorClient::CreateApplicationAsync(const CreateApplicationRequest& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::CreateApplicationAsyncHelper(const CreateApplicationRequest& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
reateAssessmentOutcome InspectorClient::CreateAssessment(const CreateAssessmentRequest& request);
reateAssessmentOutcomeCallable InspectorClient::CreateAssessmentCallable(const CreateAssessmentRequest& request);
oid InspectorClient::CreateAssessmentAsync(const CreateAssessmentRequest& request, const CreateAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::CreateAssessmentAsyncHelper(const CreateAssessmentRequest& request, const CreateAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
reateResourceGroupOutcome InspectorClient::CreateResourceGroup(const CreateResourceGroupRequest& request);
reateResourceGroupOutcomeCallable InspectorClient::CreateResourceGroupCallable(const CreateResourceGroupRequest& request);
oid InspectorClient::CreateResourceGroupAsync(const CreateResourceGroupRequest& request, const CreateResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::CreateResourceGroupAsyncHelper(const CreateResourceGroupRequest& request, const CreateResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
eleteApplicationOutcome InspectorClient::DeleteApplication(const DeleteApplicationRequest& request);
eleteApplicationOutcomeCallable InspectorClient::DeleteApplicationCallable(const DeleteApplicationRequest& request);
oid InspectorClient::DeleteApplicationAsync(const DeleteApplicationRequest& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DeleteApplicationAsyncHelper(const DeleteApplicationRequest& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
eleteAssessmentOutcome InspectorClient::DeleteAssessment(const DeleteAssessmentRequest& request);
eleteAssessmentOutcomeCallable InspectorClient::DeleteAssessmentCallable(const DeleteAssessmentRequest& request);
oid InspectorClient::DeleteAssessmentAsync(const DeleteAssessmentRequest& request, const DeleteAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DeleteAssessmentAsyncHelper(const DeleteAssessmentRequest& request, const DeleteAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
eleteRunOutcome InspectorClient::DeleteRun(const DeleteRunRequest& request);
eleteRunOutcomeCallable InspectorClient::DeleteRunCallable(const DeleteRunRequest& request);
oid InspectorClient::DeleteRunAsync(const DeleteRunRequest& request, const DeleteRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DeleteRunAsyncHelper(const DeleteRunRequest& request, const DeleteRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
escribeApplicationOutcome InspectorClient::DescribeApplication(const DescribeApplicationRequest& request);
escribeApplicationOutcomeCallable InspectorClient::DescribeApplicationCallable(const DescribeApplicationRequest& request);
oid InspectorClient::DescribeApplicationAsync(const DescribeApplicationRequest& request, const DescribeApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DescribeApplicationAsyncHelper(const DescribeApplicationRequest& request, const DescribeApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
escribeAssessmentOutcome InspectorClient::DescribeAssessment(const DescribeAssessmentRequest& request);
escribeAssessmentOutcomeCallable InspectorClient::DescribeAssessmentCallable(const DescribeAssessmentRequest& request);
oid InspectorClient::DescribeAssessmentAsync(const DescribeAssessmentRequest& request, const DescribeAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DescribeAssessmentAsyncHelper(const DescribeAssessmentRequest& request, const DescribeAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
escribeCrossAccountAccessRoleOutcome InspectorClient::DescribeCrossAccountAccessRole();
escribeCrossAccountAccessRoleOutcomeCallable InspectorClient::DescribeCrossAccountAccessRoleCallable();
oid InspectorClient::DescribeCrossAccountAccessRoleAsync(const DescribeCrossAccountAccessRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DescribeCrossAccountAccessRoleAsyncHelper(const DescribeCrossAccountAccessRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
escribeFindingOutcome InspectorClient::DescribeFinding(const DescribeFindingRequest& request);
escribeFindingOutcomeCallable InspectorClient::DescribeFindingCallable(const DescribeFindingRequest& request);
oid InspectorClient::DescribeFindingAsync(const DescribeFindingRequest& request, const DescribeFindingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DescribeFindingAsyncHelper(const DescribeFindingRequest& request, const DescribeFindingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
escribeResourceGroupOutcome InspectorClient::DescribeResourceGroup(const DescribeResourceGroupRequest& request);
escribeResourceGroupOutcomeCallable InspectorClient::DescribeResourceGroupCallable(const DescribeResourceGroupRequest& request);
oid InspectorClient::DescribeResourceGroupAsync(const DescribeResourceGroupRequest& request, const DescribeResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DescribeResourceGroupAsyncHelper(const DescribeResourceGroupRequest& request, const DescribeResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
escribeRulesPackageOutcome InspectorClient::DescribeRulesPackage(const DescribeRulesPackageRequest& request);
escribeRulesPackageOutcomeCallable InspectorClient::DescribeRulesPackageCallable(const DescribeRulesPackageRequest& request);
oid InspectorClient::DescribeRulesPackageAsync(const DescribeRulesPackageRequest& request, const DescribeRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DescribeRulesPackageAsyncHelper(const DescribeRulesPackageRequest& request, const DescribeRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
escribeRunOutcome InspectorClient::DescribeRun(const DescribeRunRequest& request);
escribeRunOutcomeCallable InspectorClient::DescribeRunCallable(const DescribeRunRequest& request);
oid InspectorClient::DescribeRunAsync(const DescribeRunRequest& request, const DescribeRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DescribeRunAsyncHelper(const DescribeRunRequest& request, const DescribeRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
etachAssessmentAndRulesPackageOutcome InspectorClient::DetachAssessmentAndRulesPackage(const DetachAssessmentAndRulesPackageRequest& request);
etachAssessmentAndRulesPackageOutcomeCallable InspectorClient::DetachAssessmentAndRulesPackageCallable(const DetachAssessmentAndRulesPackageRequest& request);
oid InspectorClient::DetachAssessmentAndRulesPackageAsync(const DetachAssessmentAndRulesPackageRequest& request, const DetachAssessmentAndRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::DetachAssessmentAndRulesPackageAsyncHelper(const DetachAssessmentAndRulesPackageRequest& request, const DetachAssessmentAndRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
etAssessmentTelemetryOutcome InspectorClient::GetAssessmentTelemetry(const GetAssessmentTelemetryRequest& request);
etAssessmentTelemetryOutcomeCallable InspectorClient::GetAssessmentTelemetryCallable(const GetAssessmentTelemetryRequest& request);
oid InspectorClient::GetAssessmentTelemetryAsync(const GetAssessmentTelemetryRequest& request, const GetAssessmentTelemetryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::GetAssessmentTelemetryAsyncHelper(const GetAssessmentTelemetryRequest& request, const GetAssessmentTelemetryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
istApplicationsOutcome InspectorClient::ListApplications(const ListApplicationsRequest& request);
istApplicationsOutcomeCallable InspectorClient::ListApplicationsCallable(const ListApplicationsRequest& request);
oid InspectorClient::ListApplicationsAsync(const ListApplicationsRequest& request, const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::ListApplicationsAsyncHelper(const ListApplicationsRequest& request, const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
istAssessmentAgentsOutcome InspectorClient::ListAssessmentAgents(const ListAssessmentAgentsRequest& request);
istAssessmentAgentsOutcomeCallable InspectorClient::ListAssessmentAgentsCallable(const ListAssessmentAgentsRequest& request);
oid InspectorClient::ListAssessmentAgentsAsync(const ListAssessmentAgentsRequest& request, const ListAssessmentAgentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::ListAssessmentAgentsAsyncHelper(const ListAssessmentAgentsRequest& request, const ListAssessmentAgentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
istAssessmentsOutcome InspectorClient::ListAssessments(const ListAssessmentsRequest& request);
istAssessmentsOutcomeCallable InspectorClient::ListAssessmentsCallable(const ListAssessmentsRequest& request);
oid InspectorClient::ListAssessmentsAsync(const ListAssessmentsRequest& request, const ListAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::ListAssessmentsAsyncHelper(const ListAssessmentsRequest& request, const ListAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
istAttachedAssessmentsOutcome InspectorClient::ListAttachedAssessments(const ListAttachedAssessmentsRequest& request);
istAttachedAssessmentsOutcomeCallable InspectorClient::ListAttachedAssessmentsCallable(const ListAttachedAssessmentsRequest& request);
oid InspectorClient::ListAttachedAssessmentsAsync(const ListAttachedAssessmentsRequest& request, const ListAttachedAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::ListAttachedAssessmentsAsyncHelper(const ListAttachedAssessmentsRequest& request, const ListAttachedAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
istAttachedRulesPackagesOutcome InspectorClient::ListAttachedRulesPackages(const ListAttachedRulesPackagesRequest& request);
istAttachedRulesPackagesOutcomeCallable InspectorClient::ListAttachedRulesPackagesCallable(const ListAttachedRulesPackagesRequest& request);
oid InspectorClient::ListAttachedRulesPackagesAsync(const ListAttachedRulesPackagesRequest& request, const ListAttachedRulesPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::ListAttachedRulesPackagesAsyncHelper(const ListAttachedRulesPackagesRequest& request, const ListAttachedRulesPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
istFindingsOutcome InspectorClient::ListFindings(const ListFindingsRequest& request);
istFindingsOutcomeCallable InspectorClient::ListFindingsCallable(const ListFindingsRequest& request);
oid InspectorClient::ListFindingsAsync(const ListFindingsRequest& request, const ListFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::ListFindingsAsyncHelper(const ListFindingsRequest& request, const ListFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
istRulesPackagesOutcome InspectorClient::ListRulesPackages(const ListRulesPackagesRequest& request);
istRulesPackagesOutcomeCallable InspectorClient::ListRulesPackagesCallable(const ListRulesPackagesRequest& request);
oid InspectorClient::ListRulesPackagesAsync(const ListRulesPackagesRequest& request, const ListRulesPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::ListRulesPackagesAsyncHelper(const ListRulesPackagesRequest& request, const ListRulesPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
istRunsOutcome InspectorClient::ListRuns(const ListRunsRequest& request);
istRunsOutcomeCallable InspectorClient::ListRunsCallable(const ListRunsRequest& request);
oid InspectorClient::ListRunsAsync(const ListRunsRequest& request, const ListRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::ListRunsAsyncHelper(const ListRunsRequest& request, const ListRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
istTagsForResourceOutcome InspectorClient::ListTagsForResource(const ListTagsForResourceRequest& request);
istTagsForResourceOutcomeCallable InspectorClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request);
oid InspectorClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
ocalizeTextOutcome InspectorClient::LocalizeText(const LocalizeTextRequest& request);
ocalizeTextOutcomeCallable InspectorClient::LocalizeTextCallable(const LocalizeTextRequest& request);
oid InspectorClient::LocalizeTextAsync(const LocalizeTextRequest& request, const LocalizeTextResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::LocalizeTextAsyncHelper(const LocalizeTextRequest& request, const LocalizeTextResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
reviewAgentsForResourceGroupOutcome InspectorClient::PreviewAgentsForResourceGroup(const PreviewAgentsForResourceGroupRequest& request);
reviewAgentsForResourceGroupOutcomeCallable InspectorClient::PreviewAgentsForResourceGroupCallable(const PreviewAgentsForResourceGroupRequest& request);
oid InspectorClient::PreviewAgentsForResourceGroupAsync(const PreviewAgentsForResourceGroupRequest& request, const PreviewAgentsForResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::PreviewAgentsForResourceGroupAsyncHelper(const PreviewAgentsForResourceGroupRequest& request, const PreviewAgentsForResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
egisterCrossAccountAccessRoleOutcome InspectorClient::RegisterCrossAccountAccessRole(const RegisterCrossAccountAccessRoleRequest& request);
egisterCrossAccountAccessRoleOutcomeCallable InspectorClient::RegisterCrossAccountAccessRoleCallable(const RegisterCrossAccountAccessRoleRequest& request);
oid InspectorClient::RegisterCrossAccountAccessRoleAsync(const RegisterCrossAccountAccessRoleRequest& request, const RegisterCrossAccountAccessRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::RegisterCrossAccountAccessRoleAsyncHelper(const RegisterCrossAccountAccessRoleRequest& request, const RegisterCrossAccountAccessRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
emoveAttributesFromFindingsOutcome InspectorClient::RemoveAttributesFromFindings(const RemoveAttributesFromFindingsRequest& request);
emoveAttributesFromFindingsOutcomeCallable InspectorClient::RemoveAttributesFromFindingsCallable(const RemoveAttributesFromFindingsRequest& request);
oid InspectorClient::RemoveAttributesFromFindingsAsync(const RemoveAttributesFromFindingsRequest& request, const RemoveAttributesFromFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::RemoveAttributesFromFindingsAsyncHelper(const RemoveAttributesFromFindingsRequest& request, const RemoveAttributesFromFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
unAssessmentOutcome InspectorClient::RunAssessment(const RunAssessmentRequest& request);
unAssessmentOutcomeCallable InspectorClient::RunAssessmentCallable(const RunAssessmentRequest& request);
oid InspectorClient::RunAssessmentAsync(const RunAssessmentRequest& request, const RunAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::RunAssessmentAsyncHelper(const RunAssessmentRequest& request, const RunAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
etTagsForResourceOutcome InspectorClient::SetTagsForResource(const SetTagsForResourceRequest& request);
etTagsForResourceOutcomeCallable InspectorClient::SetTagsForResourceCallable(const SetTagsForResourceRequest& request);
oid InspectorClient::SetTagsForResourceAsync(const SetTagsForResourceRequest& request, const SetTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::SetTagsForResourceAsyncHelper(const SetTagsForResourceRequest& request, const SetTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
tartDataCollectionOutcome InspectorClient::StartDataCollection(const StartDataCollectionRequest& request);
tartDataCollectionOutcomeCallable InspectorClient::StartDataCollectionCallable(const StartDataCollectionRequest& request);
oid InspectorClient::StartDataCollectionAsync(const StartDataCollectionRequest& request, const StartDataCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
topDataCollectionOutcome InspectorClient::StopDataCollection(const StopDataCollectionRequest& request);
topDataCollectionOutcomeCallable InspectorClient::StopDataCollectionCallable(const StopDataCollectionRequest& request);
oid InspectorClient::StopDataCollectionAsync(const StopDataCollectionRequest& request, const StopDataCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::StopDataCollectionAsyncHelper(const StopDataCollectionRequest& request, const StopDataCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
pdateApplicationOutcome InspectorClient::UpdateApplication(const UpdateApplicationRequest& request);
pdateApplicationOutcomeCallable InspectorClient::UpdateApplicationCallable(const UpdateApplicationRequest& request);
oid InspectorClient::UpdateApplicationAsync(const UpdateApplicationRequest& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::UpdateApplicationAsyncHelper(const UpdateApplicationRequest& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
pdateAssessmentOutcome InspectorClient::UpdateAssessment(const UpdateAssessmentRequest& request);
pdateAssessmentOutcomeCallable InspectorClient::UpdateAssessmentCallable(const UpdateAssessmentRequest& request);
oid InspectorClient::UpdateAssessmentAsync(const UpdateAssessmentRequest& request, const UpdateAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
oid InspectorClient::UpdateAssessmentAsyncHelper(const UpdateAssessmentRequest& request, const UpdateAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);
| 62dd9524c2d039affdbdc70be7c75e1d365b979207f8561edec6dcefd5c8ffbc | 301 |
|
rlugojr | incubator-trafodion | core/sql/sqlcomp/CmpSeabaseDDLcommon.cpp | grantSeabaseComponentPrivilege |
static void grantSeabaseComponentPrivilege(
const std::string & systemCatalog,
StmtDDLGrantComponentPrivilege *pParseNode)
{
NAString privMgrMDLoc;
CONCAT_CATSCH(privMgrMDLoc, systemCatalog.c_str(), SEABASE_PRIVMGR_SCHEMA);
PrivMgrCommands componentPrivileges(std::string(privMgrMDLoc.data()),CmpCommon::diags());
if (!CmpCommon::context()->isAuthorizationEnabled())
{
*CmpCommon::diags() << DgSqlCode(-CAT_AUTHORIZATION_NOT_ENABLED);
return;
}
const std::string componentName = pParseNode->getComponentName().data();
const ConstStringList & privList = pParseNode->getComponentPrivilegeNameList();
const NAString & granteeName = pParseNode->getUserRoleName();
int32_t granteeID;
if (ComUser::getAuthIDFromAuthName(granteeName.data(),granteeID) != 0)
{
*CmpCommon::diags() << DgSqlCode(-CAT_AUTHID_DOES_NOT_EXIST_ERROR)
<< DgString0(granteeName.data());
return;
}
int32_t grantorID = ComUser::getCurrentUser();
std::string grantorName;
ElemDDLGrantee *grantedBy = pParseNode->getGrantedBy();
if (grantedBy != NULL)
{
if (grantorID != ComUser::getRootUserID())
{
PrivMgrComponentPrivileges componentPrivileges(std::string(privMgrMDLoc.data()),CmpCommon::diags());
if (!componentPrivileges.hasSQLPriv(grantorID,
SQLOperation::MANAGE_COMPONENTS,
true))
{
*CmpCommon::diags() << DgSqlCode(-CAT_NOT_AUTHORIZED);
return;
}
}
ComString grantedByName = grantedBy->getAuthorizationIdentifier();
if (ComUser::getAuthIDFromAuthName(grantedByName.data(),grantorID) != 0)
{
*CmpCommon::diags() << DgSqlCode(-CAT_AUTHID_DOES_NOT_EXIST_ERROR)
<< DgString0(grantedByName.data());
return;
}
grantorName = grantedByName.data();
}
else
grantorName = ComUser::getCurrentUsername();
int32_t grantDepth = 0;
if (pParseNode->isWithGrantOptionSpecified())
grantDepth = -1;
vector<std::string> operationNamesList;
for (size_t i = 0; i < privList.entries(); i++)
{
const ComString * operationName = privList[i];
operationNamesList.push_back(operationName->data());
}
PrivStatus retcode = STATUS_GOOD;
retcode = componentPrivileges.grantComponentPrivilege(componentName,
operationNamesList,
grantorID,
grantorName,
granteeID,
granteeName.data(),
grantDepth);
if (retcode == STATUS_ERROR &&
CmpCommon::diags()->getNumber(DgSqlCode::ERROR_) == 0)
SEABASEDDL_INTERNAL_ERROR("GRANT COMPONENT PRIVILEGE command");
} |
CmpSeabaseDDL::CmpSeabaseDDL(NAHeap *heap, NABoolean syscatInit);
short CmpSeabaseDDL::switchCompiler(Int32 cntxtType);
short CmpSeabaseDDL::switchBackCompiler();
short CmpSeabaseDDL::createMDdescs(MDDescsInfo *&trafMDDescsInfo);
NABoolean CmpSeabaseDDL::isHbase(const NAString &catName);
ComBoolean CmpSeabaseDDL::isHbase(const ComObjectName &name);
bool CmpSeabaseDDL::isHistogramTable(const NAString &name);
bool CmpSeabaseDDL::isSampleTable(const NAString &name);
NABoolean CmpSeabaseDDL::isLOBDependentNameMatch(const NAString &name);
NABoolean CmpSeabaseDDL::isSeabase(const NAString &catName);
ComBoolean CmpSeabaseDDL::isSeabase(const ComObjectName &name);
std::vector<std::string> CmpSeabaseDDL::getHistogramTables();
ExpHbaseInterface* CmpSeabaseDDL::allocEHI(NADefaults * defs);
void CmpSeabaseDDL::deallocEHI(ExpHbaseInterface* &ehi);
ComBoolean CmpSeabaseDDL::isSeabaseMD(const ComObjectName &name);
ComBoolean CmpSeabaseDDL::isSeabasePrivMgrMD(const ComObjectName &name);
void CmpSeabaseDDL::restoreAllControlsAndFlags();
void CmpSeabaseDDL::processReturn(Lng32 retcode);
short CmpSeabaseDDL::isMetadataInitialized(ExpHbaseInterface * ehi);
NABoolean CmpSeabaseDDL::isAuthorizationEnabled();
void CmpSeabaseDDL::processSystemCatalog(NADefaults *defs);
const char * CmpSeabaseDDL::getSystemCatalog();
NAString CmpSeabaseDDL::getSystemCatalogStatic();
NABoolean CmpSeabaseDDL::xnInProgress(ExeCliInterface *cliInterface);
short CmpSeabaseDDL::beginXn(ExeCliInterface *cliInterface);
short CmpSeabaseDDL::commitXn(ExeCliInterface *cliInterface);
short CmpSeabaseDDL::rollbackXn(ExeCliInterface *cliInterface);
short CmpSeabaseDDL::autoCommit(ExeCliInterface *cliInterface, NABoolean v);
short CmpSeabaseDDL::ddlInvalidateNATables();
NABoolean CmpSeabaseDDL::enabledForSerialization(NAColumn * nac);
NABoolean CmpSeabaseDDL::isEncodingNeededForSerialization(NAColumn * nac);
static NABoolean isTrueFalseStr(const NAText& str);
static NABoolean isHBaseCompressionOption(const NAText& str);
static NABoolean isHBaseDurabilityOption(const NAText& str);
static NABoolean isHBaseEncodingOption(const NAText& str);
static NABoolean isHBaseBloomFilterOption(const NAText& str);
static short isValidHbaseName(const char * str);
short CmpSeabaseDDL::genTrafColFam(int index, NAString &trafColFamily);
short CmpSeabaseDDL::extractTrafColFam(const NAString &trafColFam, int &index);
short CmpSeabaseDDL::validateDivisionByExprForDDL(ItemExpr *divExpr);
void CmpSeabaseDDL::initSeabaseMD(NABoolean ddlXns, NABoolean minimal);
void CmpSeabaseDDL::createSeabaseMDviews();
void CmpSeabaseDDL::dropSeabaseMDviews();
void CmpSeabaseDDL::createSeabaseSchemaObjects();
short CmpSeabaseDDL::createSchemaObjects(ExeCliInterface *cliInterface);
void CmpSeabaseDDL::createSeabaseSeqTable();
short CmpSeabaseDDL::createSeqTable(ExeCliInterface *cliInterface);
void CmpSeabaseDDL::dropSeabaseMD(NABoolean ddlXns);
void CmpSeabaseDDL::dropLOBHdfsFiles();
short CmpSeabaseDDL::dropMDTable(ExpHbaseInterface *ehi, const char * tab);
void CmpSeabaseDDL::updateVersion();
void CmpSeabaseDDL::registerSeabaseUser(StmtDDLRegisterUser * authParseNode);
void CmpSeabaseDDL::alterSeabaseUser(StmtDDLAlterUser * authParseNode);
void CmpSeabaseDDL::unregisterSeabaseUser(StmtDDLRegisterUser * authParseNode);
void CmpSeabaseDDL::giveSeabaseAll(StmtDDLGiveAll * giveAllParseNode);
void CmpSeabaseDDL::giveSeabaseObject(StmtDDLGiveObject * giveObjectParseNode);
void CmpSeabaseDDL::registerSeabaseComponent(StmtDDLRegisterComponent *pParseNode);
| efb02cbd21be8406f931e81951c51284793f3291a795be8e7dd91f8f03c8f0ef | 3,113 |
|
Kobzol | kaira | libs/cailie/process_shmem.cpp | ca::Process::init_collective_operations |
void ca::Process::init_collective_operations(int process_count)
{
collective_transition_id = 0;
pthread_barrier_init(&collective_barrier1, NULL, process_count);
pthread_barrier_init(&collective_barrier2, NULL, process_count);
} |
void ca::Process::broadcast_packet(int tag, void *data, size_t size, int exclude);
void ca::Process::add_packet(int from_process, int tag, void *data, size_t size);
void Process::send(int target, Net *net, int edge_id, int tokens_count, Packer &packer, Thread *thread);
int ca::Process::process_packets(Thread *thread);
void ca::Process::setup_collective_operation(int transition_id, bool use_root, int root);
void ca::Process::collective_scatter_root(int transition_id, const void *data, size_t size);
void ca::Process::collective_scatter_nonroot(int transition_id, int root, void *out, size_t size);
void ca::Process::collective_scatterv_root(int transition_id, const void *data, int *sizes, int *displs);
void ca::Process::collective_scatterv_nonroot(int transition_id, int root, void *out, size_t size);
void ca::Process::collective_gather_root(int transition_id, const void *data, size_t size, void *out);
void ca::Process::collective_gather_nonroot(int transition_id, int root, const void *data, size_t size);
void ca::Process::collective_bcast_root(int transition_id, const void *data, size_t size);
void ca::Process::collective_bcast_nonroot(int transition_id, int root, void *out, size_t size);
void ca::Process::collective_barrier(int transition_id);
void ca::Process::collective_allgather(int transition_id, const void *data, size_t size, void *out);
| 12185fc97f248f54975a22ed26d92bae6f043bd272df9a660ac767fb54b7ca13 | 231 |
|
cbeck88 | render_engine | src/kre/BlendOGL.cpp | get_equation_stack | std::stack<BlendEquation>& get_equation_stack()
{
static std::stack<BlendEquation> res;
return res;
} | GLenum convert_eqn(BlendEquationConstants eqn);
GLenum convert_blend_mode(BlendModeConstants bm);
std::stack<BlendMode>& get_blend_mode_stack();
std::stack<bool>& get_blend_state_stack();
BlendEquationImplOGL::BlendEquationImplOGL();
BlendEquationImplOGL::~BlendEquationImplOGL();
void BlendEquationImplOGL::apply(const BlendEquation& eqn);
void BlendEquationImplOGL::clear(const BlendEquation& eqn);
BlendEquationScopeOGL::BlendEquationScopeOGL(const ScopeableValue& sv);
BlendEquationScopeOGL::~BlendEquationScopeOGL();
BlendModeScopeOGL::BlendModeScopeOGL(const ScopeableValue& sv);
BlendModeScopeOGL::~BlendModeScopeOGL();
void set_blend_mode(const BlendMode& bm);
void set_blend_equation(const BlendEquation& eqn);
| 38495c1451746987cf94491d7e11b7254748cd825420808542a0ae4f47a64f13 | 112 |
|
jasp-stats | jasp-desktop | Desktop/analysis/analysis.cpp | Analysis::createForm | oid Analysis::createForm(QQuickItem* parentItem)
{
AnalysisBase::createForm(parentItem);
if (_analysisForm)
{
connect(this, &Analysis::rSourceChanged, _analysisForm, &AnalysisForm::rSourceChanged );
connect(this, &Analysis::refreshTableViewModels, _analysisForm, &AnalysisForm::refreshTableViewModels );
connect(this, &Analysis::titleChanged, _analysisForm, &AnalysisForm::titleChanged );
connect(this, &Analysis::needsRefreshChanged, _analysisForm, &AnalysisForm::needsRefreshChanged );
connect(this, &Analysis::boundValuesChanged, _analysisForm, &AnalysisForm::setRSyntaxText, Qt::QueuedConnection );
emit analysisInitialized();
}
}
| nalysis::Analysis(size_t id, Modules::AnalysisEntry * analysisEntry, std::string title, std::string moduleVersion, Json::Value *data);
nalysis::Analysis(size_t id, Analysis * duplicateMe);
oid Analysis::initAnalysis();
nalysis::~Analysis();
ool Analysis::checkAnalysisEntry();
oid Analysis::setTitle(const std::string& title);
oid Analysis::abort();
oid Analysis::remove();
oid Analysis::setResults(const Json::Value & results, Status status, const Json::Value & progress);
oid Analysis::exportResults();
oid Analysis::run();
oid Analysis::refresh();
oid Analysis::saveImage(const Json::Value &options);
oid Analysis::imageSaved(const Json::Value & results);
oid Analysis::editImage(const Json::Value &options);
oid Analysis::imageEdited(const Json::Value & results);
ool Analysis::updatePlotSize(const std::string & plotName, int width, int height, Json::Value & root);
oid Analysis::rewriteImages();
oid Analysis::imagesRewritten(const Json::Value & results);
nalysis::Status Analysis::parseStatus(std::string name);
oid Analysis::destroyForm();
nalysis::Status Analysis::analysisResultsStatusToAnalysisStatus(analysisResultStatus result);
td::string Analysis::statusToString(Status status);
son::Value Analysis::asJSON(bool withRSource);
oid Analysis::checkDefaultTitleFromJASPFile(const Json::Value & analysisData);
oid Analysis::loadResultsUserdataAndRSourcesFromJASPFile(const Json::Value & analysisData, Status status);
oid Analysis::setStatus(Analysis::Status status);
oid Analysis::boundValueChangedHandler();
oid Analysis::requestComputedColumnCreationHandler(const std::string& columnName);
oid Analysis::requestComputedColumnDestructionHandler(const std::string& columnName);
erformType Analysis::desiredPerformTypeFromAnalysisStatus();
td::set<std::string> Analysis::usedVariables();
oid Analysis::runScriptRequestDone(const QString& result, const QString& controlName, bool hasError);
son::Value Analysis::createAnalysisRequestJson();
oid Analysis::emitDuplicationSignals();
String Analysis::fullHelpPath(QString helpFileName);
oid Analysis::duplicateMe();
oid Analysis::showDependenciesOnQMLForObject(QString uniqueName);
ool Analysis::processResultsForDependenciesToBeShownMetaTraverser(const Json::Value & array);
oid Analysis::processResultsForDependenciesToBeShown();
son::Value Analysis::editOptionsOfPlot(const std::string & uniqueName, bool emitError);
ool Analysis::_editOptionsOfPlot(const Json::Value & results, const std::string & uniqueName, Json::Value & editOptions);
oid Analysis::setEditOptionsOfPlot(const std::string & uniqueName, const Json::Value & editOptions);
ool Analysis::_setEditOptionsOfPlot(Json::Value & results, const std::string & uniqueName, const Json::Value & editOptions);
oid Analysis::setErrorInResults(const std::string & msg);
ool Analysis::readyToCreateForm();
onst stringvec & Analysis::upgradeMsgsForOption(const std::string & name);
son::Value Analysis::rSources();
oid Analysis::storeUserDataEtc();
oid Analysis::fitOldUserDataEtc();
oid Analysis::setUpgradeMsgs(const Modules::UpgradeMsgs &msgs);
oid Analysis::setVersion(Version version, bool resetWasUpgraded);
ool Analysis::needsRefresh();
ool Analysis::isWaitingForModule();
oid Analysis::setUserData(Json::Value userData);
oid Analysis::setRSources(const Json::Value &rSources);
oid Analysis::setDynamicModule(Modules::DynamicModule * module);
oid Analysis::watchQmlForm();
oid Analysis::reloadForm();
oid Analysis::analysisQMLFileChanged();
oid Analysis::checkForRSources();
oid Analysis::clearRSources();
td::string Analysis::qmlFormPath(bool addFileProtocol, bool ignoreReadyForUse);
| 6e970bb7dfc3fe55bd50483ed9bddc8f1470bb9abc684924926ebe15f02dd82e | 691 |
|
InfiniteInteractive | LimitlessSDK | sdk/Media/GPUImageSample.cpp |
GpuImageSample::GpuImageSample |
GpuImageSample::GpuImageSample():
m_flags(CL_MEM_READ_WRITE),
m_width(0),
m_height(0),
m_channels(0),
m_channelBits(0),
m_texture(0)
{} |
GpuImageSample::GpuImageSample(unsigned int width, unsigned int height, unsigned int channels, unsigned int channelBits);
GpuImageSample::GpuImageSample(unsigned char *buffer, unsigned int width, unsigned int height, unsigned int channels, unsigned int channelBits);
GpuImageSample::~GpuImageSample();
unsigned char *GpuImageSample::buffer(size_t index);
bool GpuImageSample::resize(unsigned int width, unsigned int height, unsigned int channels, unsigned int channelBits, bool inDrawThread);
bool GpuImageSample::save(std::string fileName);
bool GpuImageSample::write(IImageSample *imageSample, cl::Event &event, std::vector<cl::Event> *events);
bool GpuImageSample::write(unsigned char *buffer, unsigned int width, unsigned int height, unsigned int channels, cl::Event &event, std::vector<cl::Event> *events);
bool GpuImageSample::read(IImageSample *imageSample, cl::Event &event, std::vector<cl::Event> *events);
bool GpuImageSample::read(unsigned char *buffer, unsigned int width, unsigned int height, cl::Event &event, std::vector<cl::Event> *events);
bool GpuImageSample::copy(GpuImageSample *sample, cl::Event &event, std::vector<cl::Event> *waitEvents);
bool GpuImageSample::acquireMultipleOpenCl(std::vector<GpuImageSample *> samples, cl::Event &event, std::vector<cl::Event> *waitEvents);
bool GpuImageSample::releaseMultipleOpenCl(std::vector<GpuImageSample *> samples, cl::Event &event, std::vector<cl::Event> *waitEvents);
bool GpuImageSample::acquireOpenCl(cl::Event &event, std::vector<cl::Event> *waitEvents);
bool GpuImageSample::releaseOpenCl(cl::Event &event, std::vector<cl::Event> *waitEvents);
bool GpuImageSample::acquireOpenGl();
bool GpuImageSample::releaseOpenGl();
| 04954b29dd2a4017532d1f531b26ca8ba3ecae1575e182f823fc29ba5c7e1d89 | 136 |
|
kocubinski | opentnl | tnl/platform.cpp | Platform::debugBreak |
void Platform::debugBreak()
{
DebugBreak();
} |
void Platform::outputDebugString(const char *string);
void Platform::forceQuit();
U32 Platform::getRealMilliseconds();
void Platform::AlertOK(const char *windowTitle, const char *message);
bool Platform::AlertOKCancel(const char *windowTitle, const char *message);
bool Platform::AlertRetry(const char *windowTitle, const char *message);
WinTimer();
S64 getCurrentTime();
F64 convertToMS(S64 delta);
S64 Platform::getHighPrecisionTimerValue();
F64 Platform::getHighPrecisionMilliseconds(S64 timerDelta);
void Platform::sleep(U32 msCount);
bool Platform::checkHeap();
void Platform::outputDebugString(const char *string);
void Platform::debugBreak();
void Platform::forceQuit();
U32 Platform::getRealMilliseconds();
WinTimer();
S64 getCurrentTime();
F64 convertToMS(S64 delta);
S64 Platform::getHighPrecisionTimerValue();
F64 Platform::getHighPrecisionMilliseconds(S64 timerDelta);
void Platform::sleep(U32 msCount);
void Platform::AlertOK(const char *windowTitle, const char *message);
bool Platform::AlertOKCancel(const char *windowTitle, const char *message);
bool Platform::AlertRetry(const char *windowTitle, const char *message);
void Platform::debugBreak();
void Platform::outputDebugString(const char *string);
void Platform::forceQuit();
U32 Platform::getRealMilliseconds();
U32 x86UNIXGetTickCount();
UnixTimer();
S64 getCurrentTime();
F64 convertToMS(S64 delta);
S64 Platform::getHighPrecisionTimerValue();
F64 Platform::getHighPrecisionMilliseconds(S64 timerDelta);
void Platform::sleep(U32 msCount);
void Platform::AlertOK(const char *windowTitle, const char *message);
bool Platform::AlertOKCancel(const char *windowTitle, const char *message);
bool Platform::AlertRetry(const char *windowTitle, const char *message);
bool atob(const char *str);
S32 dSprintf(char *buffer, U32 bufferSize, const char *format, ...);
S32 dVsprintf(char *buffer, U32 bufferSize, const char *format, void *arglist);
int stricmp(const char *str1, const char *str2);
int strnicmp(const char *str1, const char *str2, unsigned int len);
| 00bb0cc9155359a00b62e676ef0a9718a2adfbe906e594bbc81a54aaf8481521 | 49 |
|
scbash | xbmc | xbmc/cores/VideoPlayer/DVDCodecs/Video/AddonVideoCodec.cpp | CAddonVideoCodec::GetPicture |
CDVDVideoCodec::VCReturn CAddonVideoCodec::GetPicture(VideoPicture* pVideoPicture)
{
if (!m_struct.toAddon.get_picture)
return CDVDVideoCodec::VC_ERROR;
VIDEOCODEC_PICTURE picture;
picture.flags = (m_codecFlags & DVD_CODEC_CTRL_DRAIN) ? VIDEOCODEC_PICTURE::FLAG_DRAIN : 0;
switch (m_struct.toAddon.get_picture(&m_struct, &picture))
{
case VIDEOCODEC_RETVAL::VC_NONE:
return CDVDVideoCodec::VC_NONE;
case VIDEOCODEC_RETVAL::VC_ERROR:
return CDVDVideoCodec::VC_ERROR;
case VIDEOCODEC_RETVAL::VC_BUFFER:
return CDVDVideoCodec::VC_BUFFER;
case VIDEOCODEC_RETVAL::VC_PICTURE:
pVideoPicture->iWidth = picture.width;
pVideoPicture->iHeight = picture.height;
pVideoPicture->pts = static_cast<double>(picture.pts);
pVideoPicture->dts = DVD_NOPTS_VALUE;
pVideoPicture->iFlags = 0;
pVideoPicture->chroma_position = 0;
pVideoPicture->colorBits = 8;
pVideoPicture->color_primaries = AVColorPrimaries::AVCOL_PRI_UNSPECIFIED;
pVideoPicture->color_range = 0;
pVideoPicture->color_space = AVCOL_SPC_UNSPECIFIED;
pVideoPicture->color_transfer = 0;
pVideoPicture->hasDisplayMetadata = false;
pVideoPicture->hasLightMetadata = false;
pVideoPicture->iDuration = 0;
pVideoPicture->iFrameType = 0;
pVideoPicture->iRepeatPicture = 0;
pVideoPicture->pict_type = 0;
pVideoPicture->qp_table = nullptr;
pVideoPicture->qscale_type = 0;
pVideoPicture->qstride = 0;
pVideoPicture->stereoMode.clear();
if (m_codecFlags & DVD_CODEC_CTRL_DROP)
pVideoPicture->iFlags |= DVP_FLAG_DROPPED;
if (pVideoPicture->videoBuffer)
pVideoPicture->videoBuffer->Release();
pVideoPicture->videoBuffer = static_cast<CVideoBuffer*>(picture.buffer);
int strides[YuvImage::MAX_PLANES], planeOffsets[YuvImage::MAX_PLANES];
for (int i = 0; i<YuvImage::MAX_PLANES; ++i)
strides[i] = picture.stride[i];
for (int i = 0; i<YuvImage::MAX_PLANES; ++i)
planeOffsets[i] = picture.planeOffsets[i];
pVideoPicture->videoBuffer->SetDimensions(picture.width, picture.height, strides, planeOffsets);
pVideoPicture->iDisplayWidth = pVideoPicture->iWidth;
pVideoPicture->iDisplayHeight = pVideoPicture->iHeight;
if (m_displayAspect > 0.0)
{
pVideoPicture->iDisplayWidth = ((int)lrint(pVideoPicture->iHeight * m_displayAspect)) & ~3;
if (pVideoPicture->iDisplayWidth > pVideoPicture->iWidth)
{
pVideoPicture->iDisplayWidth = pVideoPicture->iWidth;
pVideoPicture->iDisplayHeight = ((int)lrint(pVideoPicture->iWidth / m_displayAspect)) & ~3;
}
}
CLog::Log(LOGDEBUG, LOGVIDEO,
"CAddonVideoCodec: GetPicture::VC_PICTURE with pts {} {}x{} ({}x{}) {} {}:{} "
"offset:{},{},{}, stride:{},{},{}",
picture.pts, pVideoPicture->iWidth, pVideoPicture->iHeight,
pVideoPicture->iDisplayWidth, pVideoPicture->iDisplayHeight, m_displayAspect,
fmt::ptr(picture.decodedData), picture.decodedDataSize, picture.planeOffsets[0],
picture.planeOffsets[1], picture.planeOffsets[2], picture.stride[0],
picture.stride[1], picture.stride[2]);
if (picture.width != m_width || picture.height != m_height)
{
m_width = picture.width;
m_height = picture.height;
m_processInfo.SetVideoDimensions(m_width, m_height);
}
return CDVDVideoCodec::VC_PICTURE;
case VIDEOCODEC_RETVAL::VC_EOF:
CLog::Log(LOGINFO, "CAddonVideoCodec: GetPicture: EOF");
return CDVDVideoCodec::VC_EOF;
default:
return CDVDVideoCodec::VC_ERROR;
}
} |
CAddonVideoCodec::~CAddonVideoCodec();
bool CAddonVideoCodec::CopyToInitData(VIDEOCODEC_INITDATA &initData, CDVDStreamInfo &hints);
bool CAddonVideoCodec::Open(CDVDStreamInfo &hints, CDVDCodecOptions &options);
bool CAddonVideoCodec::Reconfigure(CDVDStreamInfo &hints);
bool CAddonVideoCodec::AddData(const DemuxPacket &packet);
const char* CAddonVideoCodec::GetName();
void CAddonVideoCodec::Reset();
bool CAddonVideoCodec::GetFrameBuffer(VIDEOCODEC_PICTURE &picture);
void CAddonVideoCodec::ReleaseFrameBuffer(KODI_HANDLE videoBufferHandle);
bool CAddonVideoCodec::get_frame_buffer(void* kodiInstance, VIDEOCODEC_PICTURE *picture);
void CAddonVideoCodec::release_frame_buffer(void* kodiInstance, KODI_HANDLE videoBufferHandle);
| 46eb100d885fd5266da5787c359ca0071e5c1a2c6d61f96bdb21d8bf0dbd9994 | 3,608 |
|
joevandyk | osg | src/osgSim/MultiSwitch.cpp | MultiSwitch::getValue |
bool MultiSwitch::getValue(unsigned int switchSet, unsigned int pos) const
{
if (switchSet>=_values.size()) return false;
const ValueList& values = _values[switchSet];
if (pos>=values.size()) return false;
return values[pos];
} |
MultiSwitch::MultiSwitch();
MultiSwitch::MultiSwitch(const MultiSwitch& sw,const osg::CopyOp& copyop);
void MultiSwitch::traverse(osg::NodeVisitor& nv);
bool MultiSwitch::addChild( osg::Node *child);
bool MultiSwitch::insertChild( unsigned int index, osg::Node *child);
bool MultiSwitch::removeChild( osg::Node *child );
void MultiSwitch::setValue(unsigned int switchSet, unsigned int pos,bool value);
void MultiSwitch::setChildValue(const osg::Node* child,unsigned int switchSet, bool value);
bool MultiSwitch::getChildValue(const osg::Node* child, unsigned int switchSet);
void MultiSwitch::expandToEncompassSwitchSet(unsigned int switchSet);
bool MultiSwitch::setAllChildrenOff(unsigned int switchSet);
bool MultiSwitch::setAllChildrenOn(unsigned int switchSet);
bool MultiSwitch::setSingleChildOn(unsigned int switchSet, unsigned int pos);
void MultiSwitch::setSwitchSetList(const SwitchSetList& switchSetList);
void MultiSwitch::setValueList(unsigned int switchSet, const ValueList& values);
| acfe75460fc6638dc05f39e0a0351bbd22e4e9d5481590e7f806035b6e1b1708 | 246 |
|
joaocc | ta3d-git | src/ta3d/src/backtrace.cpp | bug_reporter |
void bug_reporter(const String &trace)
{
bool bSendReport = false;
std::string report;
report += TA3D_ENGINE_VERSION;
#ifdef TA3D_CURRENT_REVISION
report += " r";
report += TA3D_CURRENT_REVISION;
#endif
report += '\n';
if (!TA3D_CURRENT_MOD.empty())
{
report += "MOD: ";
report += TA3D_CURRENT_MOD.c_str();
report += '\n';
}
report += "\nSystem info:\n";
#ifdef TA3D_PLATFORM_DARWIN
report += "OS: darwin\n";
#elif defined TA3D_PLATFORM_LINUX
report += "OS: linux\n";
#elif defined TA3D_PLATFORM_WINDOWS
report += "OS: windows\n";
#else
report += "OS: unknown\n";
#endif
report += "OpenGL Informations :\n";
(report += "Vendor: ") += (const char*) glGetString(GL_VENDOR);
(report += "\nRenderer: ") += (const char*) glGetString(GL_RENDERER);
(report += "\nVersion: ") += (const char*) glGetString(GL_VERSION);
report += "\nExtensions:\n";
const char *ext = (const char*) glGetString(GL_EXTENSIONS);
for(; *ext ; ++ext)
report += *ext == ' ' ? '\n' : *ext;
report += '\n';
report += '\n';
report += "\nstacktrace:\n";
report += trace.c_str();
Gui::Window wnd("Bug report", 640, 240, Gui::Window::MOVEABLE);
wnd.addChild(Gui::TabWidget_("tabs")
/ (Gui::Spacer_(false) | Gui::Button_("ok", " send report ") | Gui::Spacer_(false) | Gui::Button_("cancel", " don't send ") | Gui::Spacer_(false)));
TABWIDGET(tabs)->addTab("info", Gui::Label_("info")
/ Gui::Spacer_(true)
/ Gui::Label_("size"));
TABWIDGET(tabs)->addTab("report", Gui::ScrollArea_("scroll"));
SCROLLAREA(scroll)->setCentralWidget(Gui::Label_("text", report));
BUTTON(ok)->addListener(Gui::Utils::actionSetBool(bSendReport));
BUTTON(ok)->addListener(Gui::Utils::actionCloseWindow());
BUTTON(cancel)->addListener(Gui::Utils::actionCloseWindow());
LABEL(info)->setCaption("An error has occured.\n"
"A bug report has been prepared. You can review it in the 'report' tab.\n"
"It contains information about your version of TA3D, OS, OpenGL renderer\n"
"and a stack trace to help us find what's wrong.\n"
"\n"
"Do you want to send the bug report ?");
String buf;
buf << "(report size = " << report.size() << " bytes)";
LABEL(size)->setCaption(buf.c_str());
wnd();
if (!bSendReport)
return;
TA3D::SocketTCP sock;
sock.open("bugs.ta3d.org", 1905);
if (!sock.isOpen())
{
Gui::Utils::message("Socket error", "Error: could not connect to server.");
return;
}
sock.send("BUG REPORT\n");
sock.send(report);
sock.send("DISCONNECT");
SDL_Delay(2000);
sock.close();
Gui::Utils::message("Success", "Bug report has been sent to server.");
} |
void backtrace_handler (int signum);
virtual const char* sigpipe_what();
void sigpipe_handler (int /*signum*/);
void init_signals (void);
void clear_signals (void);
void criticalMessage(const String &msg);
| 7078d6141e317e56d120d79d37a3a8d916b0e738fd5246de13e7460b2a4135a3 | 2,633 |
|
adpg211 | bitcoin-master | src/test/TestBuffers.cpp |
BOOST_AUTO_TEST_CASE |
BOOST_AUTO_TEST_CASE(Parser)
{
MessageBuilder builder(NoHeader);
builder.add(1, "bla");
builder.add(3, 100);
builder.add(5, true);
builder.add(100, false);
std::vector<char> data;
data.push_back(5);
data.push_back(0);
data.push_back(8);
data.push_back(254);
builder.add(6, data);
builder.add(9, 15.5);
uint256 origHash;
origHash.SetHex("1298709234abd981729817291a8798172f871982a798195278312095a7982348");
builder.add(10, origHash);
ConstBuffer buf = builder.buffer();
BOOST_CHECK(buf.size() == 59);
MessageParser parser(buf);
ParsedType type = parser.next();
BOOST_CHECK(type == FoundTag);
BOOST_CHECK(parser.tag() == 1);
variant v = parser.data();
BOOST_CHECK(boost::get<std::string>(v) == std::string("bla"));
type = parser.next();
BOOST_CHECK(parser.tag() == 3);
BOOST_CHECK(type == FoundTag);
BOOST_CHECK(parser.isLong() || parser.isInt());
BOOST_CHECK(parser.intData() == 100);
type = parser.next();
BOOST_CHECK(parser.tag() == 5);
BOOST_CHECK(type == FoundTag);
BOOST_CHECK(parser.isBool());
BOOST_CHECK(parser.boolData() == true);
type = parser.next();
BOOST_CHECK(parser.tag() == 100);
BOOST_CHECK(type == FoundTag);
BOOST_CHECK(parser.isBool());
BOOST_CHECK(parser.boolData() == false);
type = parser.next();
BOOST_CHECK(parser.tag() == 6);
BOOST_CHECK(type == FoundTag);
BOOST_CHECK(parser.isByteArray());
v = parser.data();
std::vector<char> byteArray = boost::get<std::vector<char> >(v);
BOOST_CHECK(byteArray == data);
type = parser.next();
BOOST_CHECK(parser.tag() == 9);
BOOST_CHECK(type == FoundTag);
BOOST_CHECK(parser.isDouble());
v = parser.data();
double doubleData = boost::get<double>(v);
BOOST_CHECK(doubleData == 15.5);
BOOST_CHECK(parser.doubleData() == 15.5);
type = parser.next();
BOOST_CHECK(parser.tag() == 10);
BOOST_CHECK(type == FoundTag);
BOOST_CHECK(parser.isByteArray());
uint256 hash(parser.unsignedBytesData());
BOOST_CHECK(origHash == hash);
type = parser.next();
BOOST_CHECK(type == EndOfDocument);
} |
BOOST_AUTO_TEST_CASE(Basic);
BOOST_AUTO_TEST_CASE(MultiBuffer);
BOOST_AUTO_TEST_CASE(Builder);
BOOST_AUTO_TEST_CASE(StringRefInParser);
BOOST_AUTO_TEST_CASE(Clear);
BOOST_AUTO_TEST_CASE(CMFBasic);
BOOST_AUTO_TEST_CASE(CMFBasic2);
BOOST_AUTO_TEST_CASE(CMFTypes);
| fff3760e07465a9a88f4bf9edd7a61434c654c02cc1be6a27f31ba67c7e37971 | 2,198 |
|
lenovor | BBRL | src/DDS/src/Agent/VDBEEGreedyAgent.cpp | VDBEEGreedyAgent::freeData |
void VDBEEGreedyAgent::freeData()
{
if (cModel) { delete cModel; cModel = 0; }
Q.clear();
#ifndef NDEBUG
checkIntegrity();
#endif
} |
VDBEEGreedyAgent::VDBEEGreedyAgent(std::istream& is);
VDBEEGreedyAgent::~VDBEEGreedyAgent();
int VDBEEGreedyAgent::getAction(int xt);
void VDBEEGreedyAgent::learnOnline(int x, int u, int y, double r);
void VDBEEGreedyAgent::reset();
void VDBEEGreedyAgent::serialize(ostream& os);
void VDBEEGreedyAgent::deserialize(istream& is);
void VDBEEGreedyAgent::learnOffline_aux(const MDPDistribution* mdpDistrib);
void VDBEEGreedyAgent::checkIntegrity();
| 0240e06ce76acb5093628524ae0e335e4b3352ba73f5c22a57bfd30488ebe44c | 164 |
|
gsi-upm | SmartSim | smartbody/src/SmartBody/sb/SBVHMsgManager.cpp | SBVHMsgManager::getPort |
const std::string& SBVHMsgManager::getPort()
{
return _port;
} | VHMsgLogger();
virtual ~VHMsgLogger();
virtual void OnMessage( const std::string & message );
SBVHMsgManager::SBVHMsgManager();
SBVHMsgManager::~SBVHMsgManager();
void SBVHMsgManager::setEnable(bool val);
bool SBVHMsgManager::isEnable();
bool SBVHMsgManager::isConnected();
bool SBVHMsgManager::connect();
void SBVHMsgManager::disconnect();
int SBVHMsgManager::send2( const char *op, const char* message );
int SBVHMsgManager::send( const char* message );
int SBVHMsgManager::poll();
void SBVHMsgManager::setPort(const std::string& port);
void SBVHMsgManager::setServer(const std::string& server);
const std::string& SBVHMsgManager::getServer();
void SBVHMsgManager::setScope(const std::string& scope);
const std::string& SBVHMsgManager::getScope();
void SBVHMsgManager::vhmsgCallback( const char *op, const char *args, void * user_data );
void SBVHMsgManager::setEnableLogging(bool val);
bool SBVHMsgManager::isEnableLogging();
SBAPI int SBVHMsgManager::sendMessage( const std::string& message );
SBAPI int SBVHMsgManager::sendOpMessage( const std::string& op, const std::string& message );
| e19fcb2e6c4a9304d45ad5f5c2f603d9df45d7c2857e653bf0f34768b255e29f | 67 |
|
brianbbsu | program | code archive/codechef/TREEWALK.cpp | main |
int main()
{
IOS();
ll n,rt,k;
cin>>n;
REP(i,n-1)
{
ll a,b;
cin>>a>>b;
v[a].pb(b);
v[b].pb(a);
}
cin>>rt>>k;
if(k <= 3000)
{
ll dp[MAXn][MAXn];
FILL(dp,0);
dp[rt][0] = 1;
REP1(i,k)REP1(j,n)
{
for(ll t:v[j])dp[j][i] += dp[t][i-1];
dp[j][i] %= MOD;
}
REP1(i,n)cout<<dp[i][k]<<" ";
cout<<endl;
}
else
{
ll dp[2][MAXn],mat[2][MAXn][MAXn];
ll dpfg = 0,matfg = 0;
FILL(dp,0);
FILL(mat,0);
dp[0][rt] = 1;
REP1(i,n)for(ll t:v[i])mat[0][i][t] = 1;
while(k)
{
if(k & 1)
{
dpfg = !dpfg;
FILL(dp[dpfg],0);
REP1(i,n)REP1(j,n)dp[dpfg][i] += dp[!dpfg][j] * mat[matfg][j][i] % MOD;
REP1(i,n)dp[dpfg][i] %= MOD;
}
matfg = !matfg;
FILL(mat[matfg],0);
REP1(i,n)REP1(j,n)REP1(t,n)mat[matfg][i][j] += mat[!matfg][i][t] * mat[!matfg][t][j] % MOD;
REP1(i,n)REP1(j,n)mat[matfg][i][j] %= MOD;
k /= 2;
}
REP1(i,n)cout<<dp[dpfg][i]<<" ";
}
} | ostream& _OUTC(ostream &_s,It _ita,It _itb);
| 479c7169bfbdaa9451892f1e674be790cae092cac7e85524183ceb1c5b6a34c9 | 1,119 |
|
gentooza | QueTalk | app/PrefGeneral.cpp | PrefGeneral::isRosterPrefChanged | l PrefGeneral::isRosterPrefChanged() const
{
return m_hideOfflineChange
|| m_showResourcesChange
|| m_showSingleResourceChange;
}
bo | fGeneral::PrefGeneral(QWidget *parent);
fGeneral::~PrefGeneral();
on PrefGeneral::sectionIcon();
d PrefGeneral::changeEvent(QEvent *e);
ring PrefGeneral::sectionName();
d PrefGeneral::readData(Preferences *pref);
d PrefGeneral::writeData(Preferences *pref);
l PrefGeneral::isLanguageChanged();
l PrefGeneral::isRosterIconSizeChanged();
d PrefGeneral::iconSizeChanged();
| 94c943a51edc1e36e8560693790d2bccf0069533631b84b09560d72e160b5094 | 161 |
|
freaktechnik | nightingale-hacking | components/devices/base/src/sbDeviceCapabilities.cpp |
sbPlaylistFormatType::~sbPlaylistFormatType |
sbPlaylistFormatType::~sbPlaylistFormatType()
{
} |
sbDeviceCapabilities::sbDeviceCapabilities();
sbDeviceCapabilities::~sbDeviceCapabilities();
sbImageSize::~sbImageSize();
sbDevCapRange::~sbDevCapRange();
sbDevCapFraction::~sbDevCapFraction();
sbFormatTypeConstraint::~sbFormatTypeConstraint();
sbImageFormatType::~sbImageFormatType();
sbAudioFormatType::~sbAudioFormatType();
sbDevCapVideoStream::sbDevCapVideoStream();
sbDevCapVideoStream::~sbDevCapVideoStream();
NS_IMETHODIMP sbDevCapVideoStream::GetType(nsACString & aType);
NS_IMETHODIMP sbDevCapVideoStream::GetSupportedExplicitSizes(nsIArray * *aSupportedExplicitSizes);
NS_IMETHODIMP sbDevCapVideoStream::GetSupportedWidths(sbIDevCapRange * *aSupportedWidths);
NS_IMETHODIMP sbDevCapVideoStream::GetSupportedHeights(sbIDevCapRange * *aSupportedHeights);
NS_IMETHODIMP sbDevCapVideoStream::GetSupportedBitRates(sbIDevCapRange * *aSupportedBitRates);
sbDevCapAudioStream::sbDevCapAudioStream();
sbDevCapAudioStream::~sbDevCapAudioStream();
NS_IMETHODIMP sbDevCapAudioStream::GetType(nsACString & aType);
sbVideoFormatType::sbVideoFormatType();
sbVideoFormatType::~sbVideoFormatType();
sbPlaylistFormatType::sbPlaylistFormatType();
| a063366556536104ba3f3501524024edf35170268569aec3d229090bb0c89240 | 50 |
|
revelator | Revelation | Doom3/neo/framework/Common.cpp | idCommonLocal::DPrintf |
void idCommonLocal::DPrintf( const char *fmt, ... ) {
va_list argptr;
char msg[MAX_PRINT_MSG_SIZE];
if( !cvarSystem->IsInitialized() || !com_developer.GetBool() ) {
return;
}
va_start( argptr, fmt );
idStr::vsnPrintf( msg, sizeof( msg ), fmt, argptr );
va_end( argptr );
msg[sizeof( msg ) - 1] = '\0';
bool temp = com_refreshOnPrint;
com_refreshOnPrint = false;
Printf( S_COLOR_RED"%s", msg );
com_refreshOnPrint = temp;
} | version_s( void );
idCommonLocal::idCommonLocal( void );
void idCommonLocal::BeginRedirect( char *buffer, int buffersize, void ( *flush );
void idCommonLocal::EndRedirect( void );
BOOL CALLBACK EnumWindowsProc( HWND hwnd, LPARAM lParam );
bool FindEditor( void );
void idCommonLocal::CloseLogFile( void );
void idCommonLocal::SetRefreshOnPrint( bool set );
void idCommonLocal::VPrintf( const char *fmt, va_list args );
void idCommonLocal::Printf( const char *fmt, ... );
void idCommonLocal::DWarning( const char *fmt, ... );
void idCommonLocal::Warning( const char *fmt, ... );
void idCommonLocal::PrintWarnings( void );
void idCommonLocal::ClearWarnings( const char *reason );
void idCommonLocal::DumpWarnings( void );
void idCommonLocal::Error( const char *fmt, ... );
void idCommonLocal::FatalError( const char *fmt, ... );
void idCommonLocal::Quit( void );
void idCommonLocal::ParseCommandLine( int argc, const char **argv );
void idCommonLocal::ClearCommandLine( void );
bool idCommonLocal::SafeMode( void );
void idCommonLocal::CheckToolMode( void );
void idCommonLocal::StartupVariable( const char *match, bool once );
bool idCommonLocal::AddStartupCommands( void );
void idCommonLocal::InitTool( const toolFlag_t tool, const idDict *dict );
void idCommonLocal::ActivateTool( bool active );
void idCommonLocal::WriteFlaggedCVarsToFile( const char *filename, int flags, const char *setCmd );
void idCommonLocal::WriteConfigToFile( const char *filename );
void idCommonLocal::WriteConfiguration( void );
const char *idCommonLocal::KeysFromBinding( const char *bind );
const char *idCommonLocal::BindingFromKey( const char *key );
int idCommonLocal::ButtonState( int key );
int idCommonLocal::KeyState( int key );
static void Com_Editor_f( const idCmdArgs &args );
static void Com_EditGUIs_f( const idCmdArgs &args );
static void Com_MaterialEditor_f( const idCmdArgs &args );
static void PrintMemInfo_f( const idCmdArgs &args );
static void Com_EditLights_f( const idCmdArgs &args );
static void Com_EditSounds_f( const idCmdArgs &args );
static void Com_EditDecls_f( const idCmdArgs &args );
static void Com_EditAFs_f( const idCmdArgs &args );
static void Com_EditParticles_f( const idCmdArgs &args );
static void Com_EditScripts_f( const idCmdArgs &args );
static void Com_EditPDAs_f( const idCmdArgs &args );
static void Com_Error_f( const idCmdArgs &args );
static void Com_Freeze_f( const idCmdArgs &args );
static void Com_Crash_f( const idCmdArgs &args );
static void Com_Quit_f( const idCmdArgs &args );
void Com_WriteConfig_f( const idCmdArgs &args );
void Com_SetMachineSpec_f( const idCmdArgs &args );
void Com_ExecMachineSpec_f( const idCmdArgs &args );
void Com_ReloadEngine_f( const idCmdArgs &args );
const idLangDict *idCommonLocal::GetLanguageDict( void );
void idCommonLocal::FilterLangList( idStrList *list, idStr lang );
void idCommonLocal::InitLanguageDict( void );
void idCommonLocal::LocalizeSpecificMapData( const char *fileName, idLangDict &langDict, const idLangDict &replaceArgs );
void idCommonLocal::LocalizeMapData( const char *fileName, idLangDict &langDict );
void idCommonLocal::LocalizeGui( const char *fileName, idLangDict &langDict );
void Com_ReloadLanguage_f( const idCmdArgs &args );
void LoadMapLocalizeData( ListHash &listHash );
void LoadGuiParmExcludeList( idStrList &list );
bool TestMapVal( idStr &str );
bool TestGuiParm( const char *parm, const char *value, idStrList &excludeList );
void GetFileList( const char *dir, const char *ext, idStrList &list );
int LocalizeMap( const char *mapName, idLangDict &langDict, ListHash &listHash, idStrList &excludeList, bool writeFile );
void Com_LocalizeMaps_f( const idCmdArgs &args );
void Com_LocalizeGuis_f( const idCmdArgs &args );
void Com_LocalizeGuiParmsTest_f( const idCmdArgs &args );
void Com_LocalizeMapsTest_f( const idCmdArgs &args );
void Com_StartBuild_f( const idCmdArgs &args );
void Com_FinishBuild_f( const idCmdArgs &args );
void Com_Help_f( const idCmdArgs &args );
void idCommonLocal::InitCommands( void );
void idCommonLocal::InitRenderSystem( void );
void idCommonLocal::PrintLoadingMessage( const char *msg );
void idCommonLocal::InitSIMD( void );
void idCommonLocal::Frame( void );
void idCommonLocal::GUIFrame( bool execCmd, bool network );
void idCommonLocal::SingleAsyncTic( void );
void idCommonLocal::Async( void );
void idCommonLocal::LoadGameDLL( void );
void idCommonLocal::UnloadGameDLL( void );
bool idCommonLocal::IsInitialized( void );
void idCommonLocal::SetMachineSpec( void );
void idCommonLocal::Init( int argc, const char **argv, const char *cmdline );
void idCommonLocal::Shutdown( void );
void idCommonLocal::InitGame( void );
void idCommonLocal::ShutdownGame( bool reloading );
| 1005e57a23c0f0726087cf76e27ac2e6a1d447e289088db491ee23e3df55098c | 446 |
|
iPodLinux-Community | iScummVM | engines/agi/text.cpp | TextMan::blit_textbox |
void TextMan::blit_textbox(const char *p, int y, int x, int len) {
int xoff, yoff, lin, h, w;
char *msg, *m;
debugC(3, kDebugLevelText, "x=%d, y=%d, len=%d", x, y, len);
if (game.window.active)
close_window();
if (x == 0 && y == 0 && len == 0)
x = y = -1;
if (len <= 0 || len >= 40)
len = 32;
xoff = x * CHAR_COLS;
yoff = y * CHAR_LINES;
len--;
m = msg = word_wrap_string(agi_sprintf(p), &len);
for (lin = 1; *m; m++) {
if (*m == '\n' || *m == '\r')
lin++;
}
if (lin * CHAR_LINES > GFX_HEIGHT)
lin = (GFX_HEIGHT / CHAR_LINES);
w = (len + 2) * CHAR_COLS;
h = (lin + 2) * CHAR_LINES;
if (xoff < 0)
xoff = (GFX_WIDTH - w - CHAR_COLS) / 2;
else
xoff -= CHAR_COLS;
if (yoff < 0)
yoff = (GFX_HEIGHT - 3 * CHAR_LINES - h) / 2;
draw_window(xoff, yoff, xoff + w - 1, yoff + h - 1);
print_text2(2, msg, 0, CHAR_COLS + xoff, CHAR_LINES + yoff,
len + 1, MSG_BOX_TEXT, MSG_BOX_COLOUR);
free(msg);
do_update();
} |
void TextMan::erase_textbox();
void TextMan::print_text(const char *msg, int f, int x, int y, int len, int fg, int bg);
void TextMan::print_text_console(const char *msg, int x, int y, int len, int fg, int bg);
char *TextMan::word_wrap_string(char *str, int *len);
void TextMan::close_window();
int TextMan::message_box(const char *s);
int TextMan::selection_box(const char *m, const char **b);
int TextMan::print(const char *p, int lin, int col, int len);
void TextMan::print_status(const char *message, ...);
char *TextMan::safe_strcat(char *s, const char *t);
char *TextMan::agi_sprintf(const char *s);
void TextMan::write_status();
void TextMan::write_prompt();
void TextMan::clear_lines(int l1, int l2, int c);
void TextMan::flush_lines(int l1, int l2);
void TextMan::draw_window(int x1, int y1, int x2, int y2);
| e761b4b8d4b43ad3aac06befef8de8c096627ed8e113ce515920f71c254305c0 | 964 |
|
acristoffers | CMake-AVR | Arduino/Arduino/SD/Sd2Card.cpp | spiRec | tatic uint8_t spiRec(void)
{
spiSend(0XFF);
return SPDR;
}
| tatic void spiSend(uint8_t b);
int8_t spiRec(void);
oid spiSend(uint8_t data);
int8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg);
int32_t Sd2Card::cardSize(void);
oid Sd2Card::chipSelectHigh(void);
oid Sd2Card::chipSelectLow(void);
int8_t Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock);
int8_t Sd2Card::eraseSingleBlockEnable(void);
int8_t Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin);
oid Sd2Card::partialBlockRead(uint8_t value);
int8_t Sd2Card::readBlock(uint32_t block, uint8_t *dst);
int8_t Sd2Card::readData(uint32_t block, uint16_t offset, uint16_t count, uint8_t *dst);
oid Sd2Card::readEnd(void);
int8_t Sd2Card::readRegister(uint8_t cmd, void *buf);
int8_t Sd2Card::setSckRate(uint8_t sckRateID);
int8_t Sd2Card::waitNotBusy(uint16_t timeoutMillis);
int8_t Sd2Card::waitStartBlock(void);
int8_t Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t *src);
int8_t Sd2Card::writeData(const uint8_t *src);
int8_t Sd2Card::writeData(uint8_t token, const uint8_t *src);
int8_t Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount);
int8_t Sd2Card::writeStop(void);
| b65ab1e3dd927b6ed3056a5a4e14cd54ce90e60821fd72db60ab9a5563a7aeef | 72 |
|
zxymd5 | DirectXChess | Chess/ClientNetwork.cpp | CClientNetwork::RecvMsg |
int CClientNetwork::RecvMsg( char szMsg[] )
{
int nSize = CSockWrap::Recv(m_nSockFd, szMsg, MAX_MSG_SIZE, 0);
if (nSize <= 0)
{
StopClient();
}
return nSize;
} |
CClientNetwork::CClientNetwork(void);
CClientNetwork::~CClientNetwork(void);
void CClientNetwork::InitClient();
void CClientNetwork::ConnToServer( const char *pIpAddr, int nPort );
int CClientNetwork::SendMsg( char szMsg[], int nSize );
void CClientNetwork::StopClient();
| 51f6043ab0d343ae2f52fba8ee0c4277c10771a38e2a5c591ed5800d5e8b0c94 | 189 |
|
alexBraidwood | vmime | src/vmime/net/imap/IMAPCommand.cpp | IMAPCommand::SELECT |
shared_ptr <IMAPCommand> IMAPCommand::SELECT
(const bool readOnly, const string& mailboxName, const std::vector <string>& params)
{
std::ostringstream cmd;
cmd.imbue(std::locale::classic());
if (readOnly)
cmd << "EXAMINE ";
else
cmd << "SELECT ";
cmd << IMAPUtils::quoteString(mailboxName);
if (!params.empty())
{
cmd << " (";
for (size_t i = 0, n = params.size() ; i < n ; ++i)
{
if (i != 0) cmd << " ";
cmd << params[i];
}
cmd << ")";
}
return createCommand(cmd.str());
} |
IMAPCommand::IMAPCommand(const string& text, const string& traceText);
shared_ptr <IMAPCommand> IMAPCommand::LOGIN(const string& username, const string& password);
shared_ptr <IMAPCommand> IMAPCommand::AUTHENTICATE(const string& mechName);
shared_ptr <IMAPCommand> IMAPCommand::AUTHENTICATE(const string& mechName, const string& initialResponse);
shared_ptr <IMAPCommand> IMAPCommand::LIST(const string& refName, const string& mailboxName);
shared_ptr <IMAPCommand> IMAPCommand::DELETE(const string& mailboxName);
shared_ptr <IMAPCommand> IMAPCommand::STARTTLS();
shared_ptr <IMAPCommand> IMAPCommand::CAPABILITY();
shared_ptr <IMAPCommand> IMAPCommand::NOOP();
shared_ptr <IMAPCommand> IMAPCommand::EXPUNGE();
shared_ptr <IMAPCommand> IMAPCommand::CLOSE();
shared_ptr <IMAPCommand> IMAPCommand::LOGOUT();
const string IMAPCommand::getText();
const string IMAPCommand::getTraceText();
void IMAPCommand::send(shared_ptr <IMAPConnection> conn);
| af21b6d6cf1a9b66187152e4e1a2e66d028da6ca876f8c0790f035d931748b11 | 510 |
|
GOLDELEC | Huan | main/Http2Client.cpp | on_stream_close_callback |
static int on_stream_close_callback(nghttp2_session *session, int32_t stream_id,
uint32_t error_code,
void *user_data) {
ESP_LOGI(TAG, "on_stream_close_callback");
Request *req;
req = (Request *)nghttp2_session_get_stream_user_data(session, stream_id);
if (req) {
int rv;
rv = nghttp2_session_terminate_session(session, NGHTTP2_NO_ERROR);
if (rv != 0) {
ESP_LOGE(TAG, "nghttp2_session_terminate_session:%d", rv);
}
}
return 0;
} |
Http2Client::Http2Client();
Http2Client::~Http2Client();
bool Http2Client::begin(std::string host, std::string path, int port);
void Http2Client::performIo(struct Connection *connection);
void Http2Client::end();
string Http2Client::getString(void);
bool Http2Client:: connected();
void Http2Client::setTimeout(int timeout);
int Http2Client::getimeout();
bool Http2Client::connectToServer(void);
static ssize_t send_callback(nghttp2_session *session, const uint8_t *data, size_t length, int flags, void *user_data);
static ssize_t recv_callback(nghttp2_session *session, uint8_t *buf, size_t length, int flags, void *user_data);
static int on_frame_send_callback(nghttp2_session *session, const nghttp2_frame *frame, void *user_data);
static int on_frame_recv_callback(nghttp2_session *session, const nghttp2_frame *frame, void *user_data);
void Http2Client::setupNghttp2Callbacks(nghttp2_session_callbacks *callbacks);
void Http2Client::submitRequest(struct Connection *connection, struct Request *req);
bool Http2Client::initNghttp2();
| 763dc3016a66723b70284734d87ae1553514b2cdb4f83ee10d4c25da92dd934d | 536 |
|
Ansa89 | qTox | src/audio/audio.cpp | Audio::closeOutput | void Audio::closeOutput()
{
qDebug() << "Closing output";
QMutexLocker lock(audioOutLock);
if (alContext && alcMakeContextCurrent(nullptr) == ALC_TRUE)
alcDestroyContext(alContext);
if (alOutDev)
{
if (alcCloseDevice(alOutDev) == ALC_TRUE)
alOutDev = nullptr;
else
qWarning() << "Failed to close output";
}
}
| Audio& Audio::getInstance();
Audio::~Audio();
float Audio::getOutputVolume();
void Audio::setOutputVolume(float volume);
void Audio::suscribeInput();
void Audio::unsuscribeInput();
void Audio::openInput(const QString& inDevDescr);
void Audio::openOutput(const QString& outDevDescr);
void Audio::closeInput();
void Audio::playMono16Sound(const QByteArray& data);
void Audio::playGroupAudioQueued(Tox*,int group, int peer, const int16_t* data,
unsigned samples, uint8_t channels, unsigned sample_rate, void* core);
void Audio::playGroupAudio(int group, int peer, const int16_t* data,
unsigned samples, uint8_t channels, unsigned sample_rate);
void Audio::playAudioBuffer(ALuint alSource, const int16_t *data, int samples, unsigned channels, int sampleRate);
bool Audio::isInputReady();
bool Audio::isOutputClosed();
bool Audio::tryCaptureSamples(uint8_t* buf, int framesize);
void Audio::getEchoesToFilter(AudioFilterer* filterer, int framesize);
| eeef2e9a4f3408370771c66154778edb392ef3ded5f7ffb3d1e3d2ace273a9fc | 382 |
|
jbaayen | vortexje | vortexje/empirical-wakes/ramasamy-leishman-wake.cpp |
Vector3d
RamasamyLeishmanWake::vortex_ring_unit_velocity |
Vector3d
RamasamyLeishmanWake::vortex_ring_unit_velocity(const Eigen::Vector3d &x, int this_panel) const
{
if (this_panel >= n_panels() - lifting_surface->n_spanwise_panels()) {
return this->Surface::vortex_ring_unit_velocity(x, this_panel);
}
double vortex_reynolds_number = doublet_coefficients[this_panel] / RamasamyLeishmanWake::Parameters::fluid_kinematic_viscosity;
int less_than_idx;
for (less_than_idx = 0; less_than_idx < 12; less_than_idx++) {
ramasamy_leishman_data_row &row = ramasamy_leishman_data[less_than_idx];
if (vortex_reynolds_number < row.vortex_reynolds_number)
break;
}
double a[3];
double b[3];
if (less_than_idx == 0) {
a[0] = ramasamy_leishman_data[0].a_1;
a[1] = ramasamy_leishman_data[0].a_2;
b[0] = ramasamy_leishman_data[0].b_1;
b[1] = ramasamy_leishman_data[0].b_2;
b[2] = ramasamy_leishman_data[0].b_3;
} else if (less_than_idx == 12) {
a[0] = ramasamy_leishman_data[11].a_1;
a[1] = ramasamy_leishman_data[11].a_2;
b[0] = ramasamy_leishman_data[11].b_1;
b[1] = ramasamy_leishman_data[11].b_2;
b[2] = ramasamy_leishman_data[11].b_3;
} else {
double one_over_delta_vortex_reynolds_number =
1.0 / (ramasamy_leishman_data[less_than_idx].vortex_reynolds_number - ramasamy_leishman_data[less_than_idx - 1].vortex_reynolds_number);
double x = vortex_reynolds_number - ramasamy_leishman_data[less_than_idx - 1].vortex_reynolds_number;
double slope;
slope = (ramasamy_leishman_data[less_than_idx].a_1 - ramasamy_leishman_data[less_than_idx - 1].a_1) * one_over_delta_vortex_reynolds_number;
a[0] = ramasamy_leishman_data[less_than_idx - 1].a_1 + slope * x;
slope = (ramasamy_leishman_data[less_than_idx].a_2 - ramasamy_leishman_data[less_than_idx - 1].a_2) * one_over_delta_vortex_reynolds_number;
a[1] = ramasamy_leishman_data[less_than_idx - 1].a_2 + slope * x;
slope = (ramasamy_leishman_data[less_than_idx].b_1 - ramasamy_leishman_data[less_than_idx - 1].b_1) * one_over_delta_vortex_reynolds_number;
b[0] = ramasamy_leishman_data[less_than_idx - 1].b_1 + slope * x;
slope = (ramasamy_leishman_data[less_than_idx].b_2 - ramasamy_leishman_data[less_than_idx - 1].b_2) * one_over_delta_vortex_reynolds_number;
b[1] = ramasamy_leishman_data[less_than_idx - 1].b_2 + slope * x;
slope = (ramasamy_leishman_data[less_than_idx].b_3 - ramasamy_leishman_data[less_than_idx - 1].b_3) * one_over_delta_vortex_reynolds_number;
b[2] = ramasamy_leishman_data[less_than_idx - 1].b_3 + slope * x;
}
a[2] = 1 - a[0] - a[1];
Vector3d velocity(0, 0, 0);
for (int i = 0; i < (int) panel_nodes[this_panel].size(); i++) {
int previous_idx;
if (i == 0)
previous_idx = panel_nodes[this_panel].size() - 1;
else
previous_idx = i - 1;
const Vector3d &node_a = nodes[panel_nodes[this_panel][previous_idx]];
const Vector3d &node_b = nodes[panel_nodes[this_panel][i]];
Vector3d r_0 = node_b - node_a;
Vector3d r_1 = node_a - x;
Vector3d r_2 = node_b - x;
double r_0_norm = r_0.norm();
double r_1_norm = r_1.norm();
double r_2_norm = r_2.norm();
Vector3d r_1xr_2 = r_1.cross(r_2);
double r_1xr_2_sqnorm = r_1xr_2.squaredNorm();
double r_1xr_2_norm = sqrt(r_1xr_2_sqnorm);
if (r_0_norm < Vortexje::Parameters::zero_threshold ||
r_1_norm < Vortexje::Parameters::zero_threshold ||
r_2_norm < Vortexje::Parameters::zero_threshold ||
r_1xr_2_sqnorm < Vortexje::Parameters::zero_threshold)
continue;
double d = r_1xr_2_norm / r_0_norm;
double dr = pow(d / vortex_core_radii[this_panel][i], 2);
double sum = 0;
for (int j = 0; j < 3; j++)
sum += a[j] * exp(-b[j] * dr);
velocity += (1 - sum) * r_1xr_2 / r_1xr_2_sqnorm * r_0.dot(r_1 / r_1_norm - r_2 / r_2_norm);
}
return one_over_4pi * velocity;
} |
RamasamyLeishmanWake::RamasamyLeishmanWake(std::shared_ptr<LiftingSurface> lifting_surface);
| 72d3a22ef11267259c562ddd8fe07e986a4b775f28f791fc2e24b0163a895b72 | 4,359 |
|
treejames | eva | src/libeva/evaimreceive.cpp | ReceivedSystemIM::parseData |
void ReceivedSystemIM::parseData(const unsigned char *buf, const int
)
{
int pos = 0;
systemIMType = buf[pos++];
char msgLen = buf[pos++];
#ifdef WIN32
char* msg; msg=(char*)_alloca(msgLen+1);
#else
char msg[msgLen+1];
#endif
memcpy(msg, buf+pos, msgLen);
msg[0xff & msgLen]=0x00;
message.assign(msg);
} |
ReceiveIMPacket::ReceiveIMPacket(unsigned char *buf, const int len);
ReceiveIMPacket::ReceiveIMPacket(const ReceiveIMPacket &rhs);
std::string ReceiveIMPacket::convertToShow(const std::string &src, const unsigned char type);
ReceiveIMPacket &ReceiveIMPacket::operator=(const ReceiveIMPacket &rhs);
void ReceiveIMPacket::parseBody();
int ReceiveIMPacket::readHeader(const unsigned char *buf);
NormalIMBase::NormalIMBase(const unsigned char *buf, const int len);
NormalIMBase::NormalIMBase(const NormalIMBase &rhs);
NormalIMBase::~NormalIMBase();
void NormalIMBase::setNormalIMBase(const NormalIMBase *base);
void NormalIMBase::parseData();
NormalIMBase &NormalIMBase::operator=(const NormalIMBase &rhs);
void NormalIMBase::parseContents(const unsigned char *, const int );
int NormalIMBase::readHeader(const unsigned char *buf);
ReceivedNormalIM::ReceivedNormalIM(const unsigned char *buf, const int len);
ReceivedNormalIM::ReceivedNormalIM(const ReceivedNormalIM &rhs);
const bool ReceivedNormalIM::isNormalReply();
ReceivedNormalIM &ReceivedNormalIM::operator=(const ReceivedNormalIM &rhs);
void ReceivedNormalIM::parseContents(const unsigned char *buf, const int len);
ReceivedSystemIM::ReceivedSystemIM(const unsigned char *buf, const int len);
ReceivedSystemIM::ReceivedSystemIM( const ReceivedSystemIM &rhs);
ReceivedSystemIM &ReceivedSystemIM::operator=(const ReceivedSystemIM &rhs);
ReceiveIMReplyPacket::ReceiveIMReplyPacket(const char *key);
ReceiveIMReplyPacket::ReceiveIMReplyPacket(const ReceiveIMReplyPacket &rhs);
ReceiveIMReplyPacket &ReceiveIMReplyPacket::operator=(const ReceiveIMReplyPacket &rhs);
int ReceiveIMReplyPacket::putBody(unsigned char *buf);
ReceivedQunIM::ReceivedQunIM(const unsigned short src, const unsigned char * buf, const int len );
ReceivedQunIM::ReceivedQunIM( const ReceivedQunIM & rhs );
ReceivedQunIM & ReceivedQunIM::operator =( const ReceivedQunIM & rhs );
void ReceivedQunIM::parseData( const unsigned char * buf, const int len );
ReceivedQunIMJoinRequest::ReceivedQunIMJoinRequest();
ReceivedQunIMJoinRequest::ReceivedQunIMJoinRequest(const unsigned short imType, const unsigned char * buf, const int len);
ReceivedQunIMJoinRequest::ReceivedQunIMJoinRequest( const ReceivedQunIMJoinRequest & rhs );
ReceivedQunIMJoinRequest::~ReceivedQunIMJoinRequest();
ReceivedQunIMJoinRequest & ReceivedQunIMJoinRequest::operator =( const ReceivedQunIMJoinRequest & rhs );
void ReceivedQunIMJoinRequest::setCode(const unsigned char *code, const unsigned short len);
void ReceivedQunIMJoinRequest::setToken(const unsigned char *token, const unsigned short len);
SignatureChangedPacket::SignatureChangedPacket( const unsigned char * buf, const int len );
SignatureChangedPacket::SignatureChangedPacket( const SignatureChangedPacket & rhs );
SignatureChangedPacket & SignatureChangedPacket::operator =( const SignatureChangedPacket & rhs );
void SignatureChangedPacket::parseData( const unsigned char * buf, const int /*len*/ );
ReceivedFileIM::ReceivedFileIM( const unsigned char * buf, const int len );
ReceivedFileIM::ReceivedFileIM( const ReceivedFileIM & rhs );
ReceivedFileIM & ReceivedFileIM::operator =( const ReceivedFileIM & rhs );
void ReceivedFileIM::parseContents( const unsigned char * buf, const int len );
ReceivedFileExIpIM::ReceivedFileExIpIM( const unsigned char * buf, const int len );
ReceivedFileExIpIM::ReceivedFileExIpIM( const ReceivedFileExIpIM & rhs );
ReceivedFileExIpIM & ReceivedFileExIpIM::operator =( const ReceivedFileExIpIM & rhs );
void ReceivedFileExIpIM::parseContents( const unsigned char * buf, const int len );
ReceivedQQNews::ReceivedQQNews( const unsigned char * buf, const int len );
ReceivedQQNews::ReceivedQQNews( const ReceivedQQNews & rhs );
ReceivedQQNews & ReceivedQQNews::operator =( const ReceivedQQNews & rhs );
void ReceivedQQNews::parseData( const unsigned char * buf, const int /*len*/ );
| 8c7a54a939a6ad26bb59267a1fc1a40f484a5f64f6baacb0eaa365225e2d17c6 | 315 |
|
jar1karp | rstudio | src/cpp/session/SessionModuleContext.cpp | fileListingFilter |
bool fileListingFilter(const core::FileInfo& fileInfo)
{
core::FilePath filePath(fileInfo.absolutePath());
std::string ext = filePath.extensionLowerCase();
std::string name = filePath.filename();
if (ext == ".r" ||
ext == ".rprofile" ||
ext == ".rbuildignore" ||
ext == ".rdata" ||
ext == ".rhistory" ||
ext == ".ruserdata" ||
ext == ".renviron" ||
ext == ".httr-oauth" ||
ext == ".gitignore")
{
return true;
}
else if (name == ".travis.yml")
{
return true;
}
else if (userSettings().hideObjectFiles() &&
(ext == ".o" || ext == ".so" || ext == ".dll") &&
filePath.parent().filename() == "src")
{
return false;
}
else
{
return !filePath.isHidden();
}
} |
SEXP rs_enqueClientEvent(SEXP nameSEXP, SEXP dataSEXP);
SEXP rs_activatePane(SEXP paneSEXP);
SEXP rs_showErrorMessage(SEXP titleSEXP, SEXP messageSEXP);
SEXP rs_logErrorMessage(SEXP messageSEXP);
SEXP rs_logWarningMessage(SEXP messageSEXP);
SEXP rs_threadSleep(SEXP secondsSEXP);
SEXP rs_rstudioProgramMode();
SEXP rs_rstudioEdition();
SEXP rs_rstudioVersion();
SEXP rs_rstudioCitation();
SEXP rs_setUsingMingwGcc49(SEXP usingSEXP);
SEXP rs_ensureFileHidden(SEXP fileSEXP);
SEXP rs_sourceDiagnostics();
SEXP rs_packageLoaded(SEXP pkgnameSEXP);
SEXP rs_packageUnloaded(SEXP pkgnameSEXP);
SEXP rs_restartR(SEXP afterRestartSEXP);
SEXP rs_generateShortUuid();
FilePath monitoredParentPath();
bool monitoredScratchFilter(const FileInfo& fileInfo);
void onFilesChanged(const std::vector<core::system::FileChangeEvent>& changes);
boost::shared_ptr<tree<FileInfo> > monitoredPathTree();
bool scanForMonitoredPathChanges(boost::shared_ptr<tree<FileInfo> > pPrevTree);
void onMonitoringError(const Error& error);
void initializeMonitoredUserScratchDir();
void add(const SuspendHandler& handler);
void suspend(const r::session::RSuspendOptions& options,
Settings* pSettings);
void resume(const Settings& settings);
void addSuspendHandler(const SuspendHandler& handler);
void onResumed(const Settings& persistentState);
void executeScheduledCommands(ScheduledCommands* pCommands);
bool performDelayedWork(const boost::function<void();
bool isPackagePosixMakefile(const FilePath& srcPath);
void onBackgroundProcessing(bool isIdle);
core::string_utils::LineEnding lineEndings(const core::FilePath& srcFile);
FilePath userHomePath();
std::string createAliasedPath(const FileInfo& fileInfo);
std::string createAliasedPath(const FilePath& path);
FilePath resolveAliasedPath(const std::string& aliasedPath);
FilePath userScratchPath();
FilePath scopedScratchPath();
FilePath sharedScratchPath();
FilePath sessionScratchPath();
FilePath oldScopedScratchPath();
bool isVisibleUserFile(const FilePath& filePath);
FilePath safeCurrentPath();
FilePath tempFile(const std::string& prefix, const std::string& extension);
FilePath tempDir();
FilePath findProgram(const std::string& name);
bool isPdfLatexInstalled();
bool hasTextMimeType(const FilePath& filePath);
bool hasBinaryMimeType(const FilePath& filePath);
bool isJsonFile(const FilePath& filePath);
bool isTextFile(const FilePath& targetPath);
Error rBinDir(core::FilePath* pRBinDirPath);
Error rScriptPath(FilePath* pRScriptPath);
shell_utils::ShellCommand rCmd(const core::FilePath& rBinDir);
std::string rLocalHelpPort();
std::vector<FilePath> getLibPaths();
bool disablePackages();
bool isPackageInstalled(const std::string& packageName);
bool isMinimumDevtoolsInstalled();
bool isMinimumRoxygenInstalled();
std::string packageVersion(const std::string& packageName);
bool hasMinimumRVersion(const std::string &version);
Error installPackage(const std::string& pkgPath, const std::string& libPath);
std::string packageNameForSourceFile(const core::FilePath& sourceFilePath);
bool isUnmonitoredPackageSourceFile(const FilePath& filePath);
SEXP rs_packageNameForSourceFile(SEXP sourceFilePathSEXP);
SEXP rs_base64encode(SEXP dataSEXP, SEXP binarySEXP);
SEXP rs_base64decode(SEXP dataSEXP, SEXP binarySEXP);
json::Object createFileSystemItem(const FileInfo& fileInfo);
json::Object createFileSystemItem(const FilePath& filePath);
std::string rVersion();
std::string rHomeDir();
r_util::ActiveSession& activeSession();
r_util::ActiveSessions& activeSessions();
std::string libPathsString();
Error sourceModuleRFile(const std::string& rSourceFile);
void enqueClientEvent(const ClientEvent& event);
bool isDirectoryMonitored(const FilePath& directory);
bool isRScriptInPackageBuildTarget(const FilePath &filePath);
SEXP rs_isRScriptInPackageBuildTarget(SEXP filePathSEXP);
void enqueFileChangedEvent(const core::system::FileChangeEvent &event);
void consoleWriteOutput(const std::string& output);
void consoleWriteError(const std::string& message);
void showErrorMessage(const std::string& title, const std::string& message);
void showFile(const FilePath& filePath, const std::string& window);
std::string createFileUrl(const core::FilePath& filePath);
void showContent(const std::string& title, const core::FilePath& filePath);
std::string resourceFileAsString(const std::string& fileName);
bool portmapPathForLocalhostUrl(const std::string& url, std::string* pPath);
std::string mapUrlPorts(const std::string& url);
void activatePane(const std::string& pane);
FilePath shellWorkingDirectory();
Events& events();
core::system::ProcessSupervisor& processSupervisor();
FilePath sourceDiagnostics();
core::json::Object compileOutputAsJson(const CompileOutput& compileOutput);
std::string CRANReposURL();
std::string rstudioCRANReposURL();
SEXP rs_rstudioCRANReposUrl();
std::string downloadFileMethod(const std::string& defaultMethod);
std::string CRANDownloadOptions();
bool haveSecureDownloadFileMethod();
shell_utils::ShellCommand RCommand::buildRCmd(const core::FilePath& rBinDir);
std::string sessionTempDirUrl(const std::string& sessionTempPath);
bool hasStem(const FilePath& filePath, const std::string& stem);
bool isUserFile(const FilePath& filePath);
json::Value sourceMarkerJson(const SourceMarker& sourceMarker);
json::Array sourceMarkersAsJson(const std::vector<SourceMarker>& markers);
SourceMarker::Type sourceMarkerTypeFromString(const std::string& type);
bool isLoadBalanced();
bool usingMingwGcc49();
bool usingMingwGcc49();
Error initialize();
| 8065f11388cd2c7b7041a1e09f8cc103fd34dd430a371ca69c8820377c2685e7 | 809 |
|
OTSimulation | otSim | 3rdparty/gnsstk/Matrix.cpp | operator* |
Matrix operator* (const Matrix& mat1, const Matrix& mat2)
{
Matrix A;
if (!MTX_Multiply(&A.m_Matrix, &mat1.m_Matrix, &mat2.m_Matrix))
{
A.Clear();
Matrix::StaticMatrixError("operator*", "MTX_Multiply() returned false.");
return A;
}
return A;
} |
MatrixException::MatrixException(const char* msg);
MatrixException::MatrixException(const MatrixException& matrix_exception);
std::string MatrixException::GetExceptionMessage();
MatrixException::operator const char*();
Matrix::Matrix();
Matrix::~Matrix();
Matrix::Matrix(const unsigned nrows);
Matrix::Matrix(const unsigned nrows, const unsigned ncols, const bool isReal);
Matrix::Matrix(const char* path, bool& itWorked);
Matrix::Matrix(const Matrix& mat);
Matrix::Matrix(const double mat[], const unsigned nrows, const unsigned ncols);
Matrix::Matrix(const char* strMatrix);
Matrix& Matrix::operator= (const Matrix& mat);
Matrix& Matrix::operator= (const double value);
Matrix& Matrix::operator= (const std::complex<double> value);
Matrix& Matrix::operator=(const char* strMatrix);
bool Matrix::Clear();
void Matrix::MatrixError(const char* error);
void Matrix::MatrixError(const char* function, const char* error);
void Matrix::StaticMatrixError(const char* error);
void Matrix::StaticMatrixError(const char* function, const char* error);
bool Matrix::isEmpty();
bool Matrix::isConformal(const Matrix& mat);
bool Matrix::isSameSize(const Matrix& mat);
bool Matrix::isSquare();
unsigned Matrix::GetNrCols();
unsigned Matrix::ncols();
unsigned Matrix::GetNrElems();
unsigned Matrix::nelems();
unsigned Matrix::GetNrRows();
unsigned Matrix::nrows();
unsigned Matrix::GetLength();
double Matrix::real(const unsigned row, const unsigned col);
double Matrix::real(const unsigned index);
double Matrix::imag(const unsigned row, const unsigned col);
double Matrix::imag(const unsigned index);
bool Matrix::isStoredAsComplex();
bool Matrix::isReal();
bool Matrix::isComplex();
bool Matrix::isVector();
bool Matrix::ReadFromFile(const char *path);
bool Matrix::ReadFromFile(std::string path);
bool Matrix::Copy(Matrix& src);
bool Matrix::Copy(const double& value);
bool Matrix::Copy(const std::complex<double>& cplx);
bool Matrix::Save(const char* path);
bool Matrix::Save(std::string path);
bool Matrix::Print(const char *path, const unsigned precision, bool append);
bool Matrix::Print(std::string path, const unsigned precision, bool append);
bool Matrix::PrintStdout(const unsigned precision);
bool Matrix::PrintToBuffer(char* buffer, const unsigned maxlength, const unsigned precision);
bool Matrix::PrintFixedWidth(const char* path, const unsigned width, const unsigned precision, bool append);
bool Matrix::PrintFixedWidth(std::string path, const unsigned width, const unsigned precision, bool append);
bool Matrix::PrintFixedWidthToBuffer(char* buffer, const unsigned maxlength, const unsigned width, const unsigned precision);
bool Matrix::PrintDelimited(const char *path, const unsigned precision, const char delimiter, bool append);
bool Matrix::PrintDelimited(std::string path, const unsigned precision, const char delimiter, bool append);
bool Matrix::PrintDelimitedToBuffer(char *buffer, const unsigned maxlength, const unsigned precision, const char delimiter);
bool Matrix::PrintRowToString(const unsigned row, char *buffer, const unsigned maxlength, const int width, const int precision);
bool Matrix::RemoveColumn(const unsigned col);
bool Matrix::RemoveColumnsAfterIndex(const unsigned col);
bool Matrix::RemoveRowsAndColumns(const unsigned nrows, const unsigned rows[], const unsigned ncols, const unsigned cols[]);
bool Matrix::InsertColumn(const Matrix &src, const unsigned dst_col, const unsigned src_col);
bool Matrix::AddColumn(const Matrix &src, const unsigned src_col);
bool Matrix::Concatonate(const Matrix &src);
bool Matrix::Redim(const unsigned nrows, const unsigned ncols);
bool Matrix::Resize(const unsigned nrows, const unsigned ncols);
bool Matrix::SetFromStaticMatrix(const double mat[], const unsigned nrows, const unsigned ncols);
bool Matrix::SetFromMatrixString(const char* strMatrix);
bool Matrix::CopyColumn(const unsigned src_col, Matrix &dst);
bool Matrix::InsertSubMatrix(const Matrix &src, const unsigned dst_row, const unsigned dst_col);
bool Matrix::Zero();
bool Matrix::ZeroColumn(const unsigned col);
bool Matrix::ZeroRow(const unsigned row);
bool Matrix::Swap(Matrix &M);
bool Matrix::Fill(const double value);
bool Matrix::FillColumn(const unsigned col, const double value);
bool Matrix::FillRow(const unsigned row, const double value);
bool Matrix::FlipColumn(const unsigned col);
bool Matrix::FlipRow(const unsigned row);
bool Matrix::Identity();
bool Matrix::Identity(const unsigned dimension);
bool Matrix::Inplace_ForceSymmetric();
bool Matrix::Inplace_Transpose();
bool Matrix::Inplace_Round(const unsigned precision);
bool Matrix::Inplace_Floor();
bool Matrix::Inplace_Ceil();
bool Matrix::Inplace_erf();
bool Matrix::Inplace_erfinv();
bool Matrix::Inplace_erfc();
bool Matrix::Inplace_Fix();
bool Matrix::Inplace_AddScalar(const double scalar);
bool Matrix::Inplace_SubtractScalar(const double scalar);
bool Matrix::Inplace_MultiplyScalar(const double scalar);
bool Matrix::Inplace_DivideScalar(const double scalar);
bool Matrix::Inplace_PowerScalar(const double scalar);
bool Matrix::Inplace_AddScalarComplex(const std::complex<double> cplx);
bool Matrix::Inplace_SubtractScalarComplex(const std::complex<double> cplx);
bool Matrix::Inplace_MultiplyScalarComplex(const std::complex<double> cplx);
bool Matrix::Inplace_DivideScalarComplex(const std::complex<double> cplx);
bool Matrix::Inplace_PowerScalarComplex(const std::complex<double> cplx);
bool Matrix::Inplace_Abs();
bool Matrix::Inplace_acos();
bool Matrix::Inplace_acosd();
bool Matrix::Inplace_acosh();
bool Matrix::Inplace_angle();
bool Matrix::Inplace_asin();
bool Matrix::Inplace_asind();
bool Matrix::Inplace_asinh();
bool Matrix::Inplace_atan();
bool Matrix::Inplace_atand();
bool Matrix::Inplace_atanh();
bool Matrix::Inplace_Sqr();
bool Matrix::Inplace_Sqrt();
bool Matrix::Inplace_Exp();
bool Matrix::Inplace_Ln();
bool Matrix::Inplace_Increment();
bool Matrix::Inplace_Decrement();
bool Matrix::Inplace_Add(const Matrix &B);
bool Matrix::Inplace_Subtract(const Matrix &B);
bool Matrix::Inplace_PreMultiply(const Matrix &B);
bool Matrix::Inplace_TranposePreMultiply(const Matrix &B);
bool Matrix::Inplace_PostMultiply(const Matrix &B);
bool Matrix::Inplace_PostMultiplyTranspose(const Matrix &B);
bool Matrix::Inplace_DotMultiply(const Matrix &B);
bool Matrix::Inplace_DotDivide(const Matrix &B);
bool Matrix::Inplace_SortAscending();
bool Matrix::Inplace_SortDescending();
bool Matrix::Inplace_SortColumnAscending(const unsigned col);
bool Matrix::Inplace_SortColumnDescending(const unsigned col);
bool Matrix::Inplace_SortColumnIndexed(const unsigned col, Matrix &Index);
bool Matrix::Inplace_SortByColumn(const unsigned col);
bool Matrix::Inplace_Invert();
bool Matrix::Inplace_InvertRobust();
bool Matrix::Inplace_LowerTriangularInverse();
bool Matrix::Inplace_FFT();
bool Matrix::Inplace_FFT2();
bool Matrix::Inplace_IFFT();
bool Matrix::Inplace_IFFT2();
bool Matrix::Add(const Matrix &B, const Matrix &C);
bool Matrix::Subtract(const Matrix &B, const Matrix &C);
bool Matrix::Multiply(const Matrix &B, const Matrix &C);
bool Matrix::TransposeMultiply(const Matrix &B, const Matrix &C);
bool Matrix::MultiplyTranspose(const Matrix &B, const Matrix &C);
bool Matrix::Inplace_abs();
bool Matrix::Inplace_colon(double start, double increment, double end);
bool Matrix::Inplace_conj();
bool Matrix::Inplace_cos();
bool Matrix::Inplace_cosh();
bool Matrix::Inplace_cot();
bool Matrix::Inplace_coth();
bool Matrix::Inplace_imag();
bool Matrix::Inplace_exp();
bool Matrix::Inplace_eye(const unsigned nrows, const unsigned ncols);
bool Matrix::Inplace_log2();
bool Matrix::Inplace_log10();
bool Matrix::Inplace_ones(const unsigned nrows, const unsigned ncols);
bool Matrix::Inplace_real();
bool Matrix::Inplace_rand(const unsigned nrows, const unsigned ncols, const unsigned seed);
bool Matrix::Inplace_randn(const unsigned nrows, const unsigned ncols, const unsigned seed);
bool Matrix::Inplace_sin();
bool Matrix::Inplace_sinc();
bool Matrix::Inplace_sinh();
bool Matrix::Inplace_sqrt();
bool Matrix::Inplace_tan();
bool Matrix::Inplace_tanh();
bool Matrix::Inplace_zeros(const unsigned nrows, const unsigned ncols);
bool Matrix::GetStats_MaxAbs(unsigned &row, unsigned &col, double &value);
bool Matrix::GetStats_Max(unsigned &row, unsigned &col, double &re, double &im);
bool Matrix::GetStats_MaxVal(double &re, double &im);
bool Matrix::GetStats_MaxAbsCol(const unsigned col, double &value, unsigned &row);
bool Matrix::GetStats_MaxCol(const unsigned col, double &re, double &im, unsigned &row);
bool Matrix::GetStats_MaxColVal(const unsigned col, double &re, double &im);
bool Matrix::GetStats_MaxAbsRow(const unsigned row, double &value, unsigned &col);
bool Matrix::GetStats_MaxRow(const unsigned row, double &re, double &im, unsigned &col);
bool Matrix::GetStats_MaxRowVal(const unsigned row, double &re, double &im);
bool Matrix::GetStats_MinAbs(unsigned &row, unsigned &col, double &value);
bool Matrix::GetStats_Min(unsigned &row, unsigned &col, double &re, double &im);
bool Matrix::GetStats_MinVal(double &re, double &im);
bool Matrix::GetStats_MinAbsCol(const unsigned col, double &value, unsigned &row);
bool Matrix::GetStats_MinCol(const unsigned col, double &re, double &im, unsigned &row);
bool Matrix::GetStats_MinColVal(const unsigned col, double &re, double &im);
bool Matrix::GetStats_MinAbsRow(const unsigned row, double &value, unsigned &col);
bool Matrix::GetStats_MinRow(const unsigned row, double &re, double &im, unsigned &col);
bool Matrix::GetStats_MinRowVal(const unsigned row, double &re, double &im);
bool Matrix::GetStats_ColRange(const unsigned col, double &re, double &im);
bool Matrix::GetStats_RowRange(const unsigned row, double &re, double &im);
bool Matrix::GetStats_Range(double &re, double &im);
bool Matrix::GetStats_ColumnSum(const unsigned col, double &re, double &im);
bool Matrix::GetStats_RowSum(const unsigned row, double &re, double &im);
bool Matrix::GetStats_Sum(double &re, double &im);
bool Matrix::GetStats_ColumnMean(const unsigned col, double &re, double &im);
bool Matrix::GetStats_RowMean(const unsigned row, double &re, double &im);
bool Matrix::GetStats_Mean(double &re, double &im);
bool Matrix::GetStats_ColumnStdev(const unsigned col, double &value);
bool Matrix::GetStats_RowStdev(const unsigned row, double &value);
bool Matrix::GetStats_Stdev(double &value);
bool Matrix::GetStats_ColumnVar(const unsigned col, double &value);
bool Matrix::GetStats_RowVar(const unsigned row, double &value);
bool Matrix::GetStats_Var(double &value);
bool Matrix::GetStats_ColumnNorm(const unsigned col, double &value);
bool Matrix::GetStats_RowNorm(const unsigned row, double &value);
bool Matrix::GetStats_Norm(double &value);
bool Matrix::GetStats_ColumnRMS(const unsigned col, double &value);
bool Matrix::GetStats_RowRMS(const unsigned row, double &value);
bool Matrix::GetStats_RMS(double &value);
bool Matrix::GetStats_ColumnSkewness(const unsigned col, double &re, double &im);
bool Matrix::GetStats_RowSkewness(const unsigned row, double &re, double &im);
bool Matrix::GetStats_Skewness(double &re, double &im);
bool Matrix::GetStats_ColumnKurtosis(const unsigned col, double &re, double &im);
bool Matrix::GetStats_RowKurtosis(const unsigned row, double &re, double &im);
bool Matrix::GetStats_Kurtosis(double &re, double &im);
bool Matrix::GetTrace(double &re, double &im);
bool Matrix::GetDeterminant(double &re, double &im);
bool Matrix::GetDiagonal(Matrix& DiagonalVector);
bool Matrix::GetColumnMovAvg(const unsigned col, const unsigned lead, const unsigned lag, Matrix &MovAvg);
bool Matrix::GetMovAvg(const unsigned lead, const unsigned lag, Matrix &MovAvg);
bool Matrix::GetATAInverse(Matrix &InvATA);
bool Matrix::GetLUFactorization(bool &isFullRank, Matrix &P, Matrix &L, Matrix &U);
bool Matrix::GetIndexedValues(Matrix& RowIndex, Matrix& ColIndex, Matrix& Result);
bool Matrix::SetIndexedValues(Matrix& RowIndex, Matrix& ColIndex, Matrix& SourceData);
std::string Matrix::GetMatrixComment();
Matrix Matrix::Column(const unsigned col);
Matrix Matrix::Row(const unsigned row);
Matrix Matrix::Transpose();
Matrix Matrix::T();
Matrix Matrix::Diagonal();
Matrix Matrix::Inverse();
Matrix Matrix::Inv();
Matrix Matrix::FFT();
Matrix Matrix::FFT2();
Matrix Matrix::IFFT();
Matrix Matrix::IFFT2();
Matrix Matrix::DotMultiply(const Matrix& B);
Matrix Matrix::Real();
Matrix Matrix::Imag();
Matrix Matrix::conj();
Matrix Matrix::AddIdentity();
Matrix Matrix::MinusIdentity();
Matrix Matrix::IdentityMinusMe();
Matrix Matrix::Negate();
Matrix Matrix::Sqrt();
Matrix Matrix::Exp();
Matrix Matrix::Ln();
Matrix Matrix::cos();
Matrix Matrix::acos();
Matrix Matrix::sin();
Matrix Matrix::asin();
Matrix Matrix::tan();
Matrix Matrix::atan();
Matrix Matrix::cosh();
Matrix Matrix::sinh();
Matrix Matrix::tanh();
Matrix Matrix::cot();
Matrix Matrix::coth();
Matrix Matrix::abs();
Matrix Matrix::angle();
Matrix Matrix::pow(const double power_re, const double power_im);
Matrix Matrix::round(const unsigned precision);
Matrix Matrix::floor();
Matrix Matrix::ceil();
Matrix Matrix::fix();
Matrix Matrix::dotInvert();
Matrix Matrix::oneMinusMe();
Matrix::Element& Matrix::operator();
Matrix::Element& Matrix::operator();
Matrix::Element::Element(MTX& mtx);
Matrix::Element::~Element();
const double Matrix::Element::real();
const double Matrix::Element::imag();
const Matrix::Element& Matrix::Element::operator= (double v);
const Matrix::Element& Matrix::Element::operator= (std::complex<double> v);
const Matrix::Element& Matrix::Element::operator= (Element v);
Matrix::Element::operator const std::complex<double>();
void Matrix::Element::operator+= (const double scalar);
void Matrix::Element::operator+= (const std::complex<double>& v);
void Matrix::Element::operator+= (const Element& v);
void Matrix::Element::operator-= (const double scalar);
void Matrix::Element::operator-= (const std::complex<double>& v);
void Matrix::Element::operator-= (const Element& v);
void Matrix::Element::operator*= (const double scalar);
void Matrix::Element::operator*= (const std::complex<double>& v);
void Matrix::Element::operator*= (const Element& v);
void Matrix::Element::operator/= (const double scalar);
void Matrix::Element::operator/= (const std::complex<double>& v);
void Matrix::Element::operator/= (const Element& v);
const std::complex<double> operator+ (const Matrix::Element& m, double scalar);
const std::complex<double> operator+ (const Matrix::Element& a, const Matrix::Element& b);
const std::complex<double> operator+ (const Matrix::Element& a, const std::complex<double>& b);
const std::complex<double> operator+ (double scalar, const Matrix::Element& m);
const std::complex<double> operator+ (const std::complex<double>& b, const Matrix::Element& a);
const std::complex<double> operator- (const Matrix::Element& m, double scalar);
const std::complex<double> operator- (const Matrix::Element& a, const Matrix::Element& b);
const std::complex<double> operator- (const Matrix::Element& a, const std::complex<double>& b);
const std::complex<double> operator- (double scalar, const Matrix::Element& m);
const std::complex<double> operator- (const std::complex<double>& b, const Matrix::Element& a);
const std::complex<double> operator* (const Matrix::Element& m, double scalar);
const std::complex<double> operator* (const Matrix::Element& a, const Matrix::Element& b);
const std::complex<double> operator* (const Matrix::Element& a, const std::complex<double>& b);
const std::complex<double> operator* (double scalar, const Matrix::Element& m);
const std::complex<double> operator* (const std::complex<double>& b, const Matrix::Element& a);
const std::complex<double> operator/ (const Matrix::Element& m, double scalar);
const std::complex<double> operator/ (const Matrix::Element& a, const Matrix::Element& b);
const std::complex<double> operator/ (const Matrix::Element& a, const std::complex<double>& b);
const std::complex<double> operator/ (double scalar, const Matrix::Element& m);
const std::complex<double> operator/ (const std::complex<double>& b, const Matrix::Element& a);
const bool operator== (const Matrix::Element& m, double scalar);
const bool operator== (const Matrix::Element& a, const Matrix::Element& b);
const bool operator== (const Matrix::Element& a, const std::complex<double>& b);
const bool operator== (double scalar, const Matrix::Element& m);
const bool operator== (const std::complex<double>& b, const Matrix::Element& a);
bool Matrix::operator+= (const double scalar);
bool Matrix::operator+= (const std::complex<double> cplx);
bool Matrix::operator-= (const double scalar);
bool Matrix::operator-= (const std::complex<double> cplx);
bool Matrix::operator*= (const double scalar);
bool Matrix::operator*= (const std::complex<double> cplx);
bool Matrix::operator/= (double scalar);
bool Matrix::operator/= (const std::complex<double> cplx);
bool Matrix::operator+= (const Matrix& mat);
bool Matrix::operator-= (const Matrix& mat);
Matrix operator++ (Matrix& mat, int);
Matrix operator-- (Matrix& mat, int);
Matrix operator* (Matrix& mat1, Matrix& mat2);
Matrix operator+ (Matrix& mat1, Matrix& mat2);
Matrix operator+ (const Matrix& mat1, const Matrix& mat2);
Matrix operator- (Matrix& mat1, Matrix& mat2);
Matrix operator- (const Matrix& mat1, const Matrix& mat2);
Matrix operator^ (Matrix& mat, const double scalar);
Matrix operator+ (const double scalar, Matrix& mat);
Matrix operator- (const double scalar, Matrix& mat);
Matrix operator* (const double scalar, Matrix& mat);
Matrix operator/ (Matrix& mat, const double scalar);
Matrix operator/ (const double scalar, Matrix& mat);
ostream& operator<< (ostream& strm, const Matrix& mat);
bool Matrix::IndexCheck(const unsigned row, const unsigned col);
bool Matrix::IndexCheck(const unsigned index);
Matrix::RealOnlyAccess::RealOnlyAccess(MTX& mtx, const unsigned row);
Matrix::RealOnlyAccess::~RealOnlyAccess();
bool Matrix::RealOnlyAccess::IndexCheck(const unsigned row, const unsigned col);
bool Matrix::RealOnlyAccess::IndexCheck(const unsigned index);
double& Matrix::RealOnlyAccess::operator [] (const unsigned col);
Matrix::RealOnlyAccess Matrix::operator[] (const unsigned row);
Matrix::RealOnlyAccess& Matrix::RealOnlyAccess::operator=(const double value);
Matrix::RealOnlyAccess& Matrix::RealOnlyAccess::operator=(RealOnlyAccess& rhs);
Matrix::RealOnlyAccess& Matrix::RealOnlyAccess::operator=(Matrix::Element& rhs);
Matrix::RealOnlyAccess::operator const double();
bool Matrix::RealOnlyAccess::operator+= (const double scalar);
bool Matrix::RealOnlyAccess::operator-= (const double scalar);
bool Matrix::RealOnlyAccess::operator*= (const double scalar);
bool Matrix::RealOnlyAccess::operator/= (double scalar);
bool Matrix::Hilbert(const unsigned N);
| 0b5b6849d0d7c30041b80990e6ff40707335d6b8dbc97957f5b77bc0e44df1bd | 258 |
|
zeng-bioinfo | thu-samlib | cst/rbtree.cpp | RBTree::leftRotate |
void RBTree::leftRotate(RBNode* x, void (*updateNode)(RBNode* n, RBTree *T)){
RBNode* y = x->right;
x->right=y->left;
if (y->left != nil) y->left->parent=x;
y->parent=x->parent;
if (x->parent==this->nil)
root=y;
else {
if (x == x->parent->left)
x->parent->left=y;
else
x->parent->right=y;
}
y->left=x;
x->parent=y;
if (updateNode != 0) {
updateNode(x, this);
updateNode(y, this);
}
} |
void RBTree::checkTree();
void RBTree::rightRotate(RBNode* x, void (*updateNode);
void RBTree::rbInsertFixup(RBNode* z, void (*updateNode);
void RBTree::rbDeleteFixup(RBNode *x, void (*updateNode);
void RBTree::rbDelete(RBNode *z, void (*updateNode);
RBNode* RBTree::treeSuccessor(RBNode *x);
RBNode* RBTree::treePredeccessor(RBNode *x);
RBNode* RBTree::treeMinimum(RBNode *x);
RBNode* RBTree::treeMaximum(RBNode *x);
bool RBTree::isLeftChild(RBNode *n);
bool RBTree::isRightChild(RBNode *n);
RBNode* RBTree::findRightSiblingLeaf(RBNode *n);
RBNode* RBTree::findLeftSiblingLeaf(RBNode *n);
int RBTree::getNodeMaxDepth(RBNode *n);
int RBTree::getNodeMinDepth(RBNode *n);
void RBTree::printSubTree(RBNode *n);
void RBTree::checkSubTree(RBNode *n);
void RBTree::checkNode(RBNode *n);
| 4c033afe33afcbd67d4a869625ef6b0f2aab4abbe83ada679ec0f8d1778e8ef3 | 416 |
|
SrNetoChan | QGIS | src/app/maptools/qgsmaptoolshapecircle2points.cpp | QgsMapToolShapeCircle2PointsMetadata::category | QgsMapToolShapeAbstract::ShapeCategory QgsMapToolShapeCircle2PointsMetadata::category() const
{
return QgsMapToolShapeAbstract::ShapeCategory::Circle;
}
| QString QgsMapToolShapeCircle2PointsMetadata::id();
QString QgsMapToolShapeCircle2PointsMetadata::name();
QIcon QgsMapToolShapeCircle2PointsMetadata::icon();
QgsMapToolShapeAbstract *QgsMapToolShapeCircle2PointsMetadata::factory( QgsMapToolCapture *parentTool );
bool QgsMapToolShapeCircle2Points::cadCanvasReleaseEvent( QgsMapMouseEvent *e, QgsMapToolCapture::CaptureMode mode );
void QgsMapToolShapeCircle2Points::cadCanvasMoveEvent( QgsMapMouseEvent *e, QgsMapToolCapture::CaptureMode mode );
| fc9d3eee287b2ee2ade2225c2d6a51117acb54bfde5e786bd3e6074ad62f5865 | 155 |
|
dudochkin-victor | libgogootouch | src/views/mlistitemview.cpp | MListItemViewPrivate::_q_applyReleasedStyle |
void MListItemViewPrivate::_q_applyReleasedStyle()
{
Q_Q(MListItemView);
setSelected(controller->isSelected());
if (!tapAndHoldStarted && controller->graphicsEffect())
controller->setGraphicsEffect(NULL);
q->applyStyle();
q->update();
} |
MListItemViewPrivate::MListItemViewPrivate(MWidgetController *controller);
MListItemViewPrivate::~MListItemViewPrivate();
void MListItemViewPrivate::init();
void MListItemViewPrivate::_q_applyPressedStyle();
void MListItemViewPrivate::click();
void MListItemViewPrivate::longTap(const QPointF &pos);
MListItemView::MListItemView(MWidgetController *controller);
void MListItemView::mousePressEvent(QGraphicsSceneMouseEvent *event);
void MListItemView::mouseReleaseEvent(QGraphicsSceneMouseEvent *event);
void MListItemView::mouseMoveEvent(QGraphicsSceneMouseEvent *event);
void MListItemView::cancelEvent(MCancelEvent *event);
void MListItemView::tapAndHoldGestureEvent(QGestureEvent *event, QTapAndHoldGesture *gesture);
| 2ba9fb2fefe07bd417835747e2c12c0c7b2284d2a4db9a8cba867936ecc974bf | 268 |
|
aporto | arduino | arduino_motor/libraries/PololuWheelEncoders/PololuWheelEncoders.cpp | PololuWheelEncoders::getCountsM1 |
int PololuWheelEncoders::getCountsM1()
{
cli();
int tmp = global_counts_m1;
sei();
return tmp;
} | void encoders_init(unsigned char m1a, unsigned char m1b, unsigned char m2a, unsigned char m2b);
int encoders_get_counts_m1();
int encoders_get_counts_m2();
int encoders_get_counts_and_reset_m1();
int encoders_get_counts_and_reset_m2();
int encoders_check_error_m1();
int encoders_check_error_m2();
ISR(PCINT0_vect);
static void enable_interrupts_for_pin(unsigned char p);
void PololuWheelEncoders::init(unsigned char m1a, unsigned char m1b, unsigned char m2a, unsigned char m2b);
int PololuWheelEncoders::getCountsM2();
int PololuWheelEncoders::getCountsAndResetM1();
int PololuWheelEncoders::getCountsAndResetM2();
unsigned char PololuWheelEncoders::checkErrorM1();
unsigned char PololuWheelEncoders::checkErrorM2();
| 6889f3b72dfda66b575ed0ed1ac019f0697dd14d9fe82dc4b699c2f15e56e9fa | 101 |
|
gabeharms | firestorm | indra/newview/llvoavatarself.cpp | LLVOAvatarSelf::dumpWearableInfo |
void LLVOAvatarSelf::dumpWearableInfo(LLAPRFile& outfile)
{
LLAPRFile::tFiletype* file = outfile.getFileHandle();
if (!file)
{
return;
}
apr_file_printf( file, "\n<wearable_info>\n" );
LLWearableData *wd = getWearableData();
for (S32 type = 0; type < LLWearableType::WT_COUNT; type++)
{
const std::string& type_name = LLWearableType::getTypeName((LLWearableType::EType)type);
for (U32 j=0; j< wd->getWearableCount((LLWearableType::EType)type); j++)
{
LLViewerWearable *wearable = gAgentWearables.getViewerWearable((LLWearableType::EType)type,j);
apr_file_printf( file, "\n\t <wearable type=\"%s\" name=\"%s\"/>\n",
type_name.c_str(), wearable->getName().c_str() );
LLWearable::visual_param_vec_t v_params;
wearable->getVisualParams(v_params);
for (LLWearable::visual_param_vec_t::iterator it = v_params.begin();
it != v_params.end(); ++it)
{
LLVisualParam *param = *it;
dump_visual_param(file, param, param->getWeight());
}
}
}
apr_file_printf( file, "\n</wearable_info>\n" );
} |
BOOL isAgentAvatarValid();
void selfStartPhase(const std::string& phase_name);
void selfStopPhase(const std::string& phase_name, bool err_check);
void selfClearPhases();
LocalTextureData();
bool output_self_av_texture_diagnostics();
bool update_avatar_rez_metrics();
bool check_for_unsupported_baked_appearance();
void LLVOAvatarSelf::initInstance();
void LLVOAvatarSelf::markDead();
BOOL LLVOAvatarSelf::loadAvatar();
BOOL LLVOAvatarSelf::loadAvatarSelf();
BOOL LLVOAvatarSelf::buildSkeletonSelf(const LLAvatarSkeletonInfo *info);
BOOL LLVOAvatarSelf::buildMenus();
void LLVOAvatarSelf::cleanup();
LLVOAvatarSelf::~LLVOAvatarSelf();
BOOL LLVOAvatarSelf::updateCharacter(LLAgent &agent);
BOOL LLVOAvatarSelf::isValid();
void LLVOAvatarSelf::idleUpdate(LLAgent &agent, const F64 &time);
LLJoint *LLVOAvatarSelf::getJoint(const std::string &name);
void LLVOAvatarSelf::resetJointPositions( void );
BOOL LLVOAvatarSelf::setVisualParamWeight(const LLVisualParam *which_param, F32 weight, BOOL upload_bake );
BOOL LLVOAvatarSelf::setVisualParamWeight(const char* param_name, F32 weight, BOOL upload_bake );
BOOL LLVOAvatarSelf::setVisualParamWeight(S32 index, F32 weight, BOOL upload_bake );
BOOL LLVOAvatarSelf::setParamWeight(const LLViewerVisualParam *param, F32 weight, BOOL upload_bake );
void LLVOAvatarSelf::updateVisualParams();
void LLVOAvatarSelf::idleUpdateAppearanceAnimation();
void LLVOAvatarSelf::requestStopMotion(LLMotion* motion);
void LLVOAvatarSelf::stopMotionFromSource(const LLUUID& source_id);
void LLVOAvatarSelf::setLocalTextureTE(U8 te, LLViewerTexture* image, U32 index);
void LLVOAvatarSelf::removeMissingBakedTextures();
void LLVOAvatarSelf::updateRegion(LLViewerRegion *regionp);
void LLVOAvatarSelf::idleUpdateTractorBeam();
void LLVOAvatarSelf::restoreMeshData();
void LLVOAvatarSelf::updateAttachmentVisibility(U32 camera_mode);
void LLVOAvatarSelf::wearableUpdated( LLWearableType::EType type, BOOL upload_result );
BOOL LLVOAvatarSelf::isWearingAttachment(const LLUUID& inv_item_id);
BOOL LLVOAvatarSelf::attachmentWasRequested(const LLUUID& inv_item_id);
void LLVOAvatarSelf::addAttachmentRequest(const LLUUID& inv_item_id);
void LLVOAvatarSelf::removeAttachmentRequest(const LLUUID& inv_item_id);
LLViewerObject* LLVOAvatarSelf::getWornAttachment(const LLUUID& inv_item_id);
boost::signals2::connection LLVOAvatarSelf::setAttachmentCallback(const attachment_signal_t::slot_type& cb);
LLViewerJointAttachment* LLVOAvatarSelf::getWornAttachmentPoint(const LLUUID& idItem);
const std::string LLVOAvatarSelf::getAttachedPointName(const LLUUID& inv_item_id);
const LLViewerJointAttachment *LLVOAvatarSelf::attachObject(LLViewerObject *viewer_object);
BOOL LLVOAvatarSelf::detachObject(LLViewerObject *viewer_object);
BOOL LLVOAvatarSelf::detachAttachmentIntoInventory(const LLUUID &item_id);
U32 LLVOAvatarSelf::getNumWearables(LLAvatarAppearanceDefines::ETextureIndex i);
void LLVOAvatarSelf::localTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src_raw, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
BOOL LLVOAvatarSelf::getLocalTextureGL(ETextureIndex type, LLViewerTexture** tex_pp, U32 index);
LLViewerFetchedTexture* LLVOAvatarSelf::getLocalTextureGL(LLAvatarAppearanceDefines::ETextureIndex type, U32 index);
const LLUUID& LLVOAvatarSelf::getLocalTextureID(ETextureIndex type, U32 index);
BOOL LLVOAvatarSelf::isLocalTextureDataAvailable(const LLViewerTexLayerSet* layerset);
BOOL LLVOAvatarSelf::isLocalTextureDataFinal(const LLViewerTexLayerSet* layerset);
BOOL LLVOAvatarSelf::isAllLocalTextureDataFinal();
BOOL LLVOAvatarSelf::isBakedTextureFinal(const LLAvatarAppearanceDefines::EBakedTextureIndex index);
BOOL LLVOAvatarSelf::isTextureDefined(LLAvatarAppearanceDefines::ETextureIndex type, U32 index);
BOOL LLVOAvatarSelf::isTextureVisible(LLAvatarAppearanceDefines::ETextureIndex type, U32 index);
BOOL LLVOAvatarSelf::isTextureVisible(LLAvatarAppearanceDefines::ETextureIndex type, LLViewerWearable *wearable);
void LLVOAvatarSelf::requestLayerSetUploads();
void LLVOAvatarSelf::requestLayerSetUpload(LLAvatarAppearanceDefines::EBakedTextureIndex i);
bool LLVOAvatarSelf::areTexturesCurrent();
bool LLVOAvatarSelf::hasPendingBakedUploads();
void LLVOAvatarSelf::invalidateComposite( LLTexLayerSet* layerset, BOOL upload_result );
void LLVOAvatarSelf::invalidateAll();
void LLVOAvatarSelf::setCompositeUpdatesEnabled( bool b );
void LLVOAvatarSelf::setCompositeUpdatesEnabled(U32 index, bool b);
bool LLVOAvatarSelf::isCompositeUpdateEnabled(U32 index);
void LLVOAvatarSelf::setupComposites();
void LLVOAvatarSelf::updateComposites();
S32 LLVOAvatarSelf::getLocalDiscardLevel(ETextureIndex type, U32 wearable_index);
void LLVOAvatarSelf::getLocalTextureByteCount(S32* gl_bytes);
void LLVOAvatarSelf::setLocalTexture(ETextureIndex type, LLViewerTexture* src_tex, BOOL baked_version_ready, U32 index);
void LLVOAvatarSelf::setBakedReady(LLAvatarAppearanceDefines::ETextureIndex type, BOOL baked_version_exists, U32 index);
void LLVOAvatarSelf::dumpLocalTextures();
void LLVOAvatarSelf::onLocalTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src_raw, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
void LLVOAvatarSelf::setImage(const U8 te, LLViewerTexture *imagep, const U32 index);
LLViewerTexture* LLVOAvatarSelf::getImage(const U8 te, const U32 index);
void LLVOAvatarSelf::dumpTotalLocalTextureByteCount();
BOOL LLVOAvatarSelf::getIsCloud();
void LLVOAvatarSelf::debugOnTimingLocalTexLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
void LLVOAvatarSelf::debugTimingLocalTexLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata);
void LLVOAvatarSelf::debugBakedTextureUpload(EBakedTextureIndex index, BOOL finished);
const std::string LLVOAvatarSelf::verboseDebugDumpLocalTextureDataInfo(const LLViewerTexLayerSet* layerset);
void LLVOAvatarSelf::dumpAllTextures();
const std::string LLVOAvatarSelf::debugDumpLocalTextureDataInfo(const LLViewerTexLayerSet* layerset);
const std::string LLVOAvatarSelf::debugDumpAllLocalTextureDataInfo();
LLSD LLVOAvatarSelf::metricsData();
void result(const LLSD & content);
bool LLVOAvatarSelf::updateAvatarRezMetrics(bool force_send);
void LLVOAvatarSelf::addMetricsTimerRecord(const LLSD& record);
bool operator<(const LLSD& a, const LLSD& b);
void LLVOAvatarSelf::sendViewerAppearanceChangeMetrics();
CheckAgentAppearanceServiceResponder();
virtual ~CheckAgentAppearanceServiceResponder();
void result(const LLSD& content);
void errorWithContent(U32 status, const std::string& reason, const LLSD& content);
static void forceAppearanceUpdate();
void LLVOAvatarSelf::checkForUnsupportedServerBakeAppearance();
const LLUUID& LLVOAvatarSelf::grabBakedTexture(EBakedTextureIndex baked_index);
BOOL LLVOAvatarSelf::canGrabBakedTexture(EBakedTextureIndex baked_index);
LLLocalTextureObject* LLVOAvatarSelf::getLocalTextureObject(LLAvatarAppearanceDefines::ETextureIndex i, U32 wearable_index);
ETextureIndex LLVOAvatarSelf::getBakedTE( const LLViewerTexLayerSet* layerset );
void LLVOAvatarSelf::setNewBakedTexture(LLAvatarAppearanceDefines::EBakedTextureIndex i, const LLUUID &uuid);
void LLVOAvatarSelf::setNewBakedTexture( ETextureIndex te, const LLUUID& uuid );
void LLVOAvatarSelf::outputRezDiagnostics();
void LLVOAvatarSelf::outputRezTiming(const std::string& msg);
void LLVOAvatarSelf::reportAvatarRezTime();
void LLVOAvatarSelf::setCachedBakedTexture( ETextureIndex te, const LLUUID& uuid );
void LLVOAvatarSelf::processRebakeAvatarTextures(LLMessageSystem* msg, void**);
void LLVOAvatarSelf::forceBakeAllTextures(bool slam_for_debug);
void LLVOAvatarSelf::requestLayerSetUpdate(ETextureIndex index );
LLViewerTexLayerSet* LLVOAvatarSelf::getLayerSet(ETextureIndex index);
LLViewerTexLayerSet* LLVOAvatarSelf::getLayerSet(EBakedTextureIndex baked_index);
void LLVOAvatarSelf::onCustomizeStart(bool disable_camera_switch);
void LLVOAvatarSelf::onCustomizeEnd(bool disable_camera_switch);
bool LLVOAvatarSelf::sendAppearanceMessage(LLMessageSystem *mesgsys);
BOOL LLVOAvatarSelf::needsRenderBeam();
void LLVOAvatarSelf::deleteScratchTextures();
void LLVOAvatarSelf::dumpScratchTextureByteCount();
F32 LLVOAvatarSelf::getAvatarOffset();
| 4380424a7fa4d188259c2464d5f34960aef7b2c029f43758b91dfb084d861961 | 1,058 |
|
pombredanne | metamorphosys-desktop | metamorphosys/tonka/models/SystemC/systemc-2.3.0/src/sysc/kernel/sc_method_process.cpp | sc_method_process::kill_process |
void sc_method_process::kill_process(sc_descendant_inclusion_info descendants)
{
if ( sc_get_status() == SC_ELABORATION )
{
report_error( SC_ID_KILL_PROCESS_WHILE_UNITIALIZED_ );
}
if ( descendants == SC_INCLUDE_DESCENDANTS )
{
const std::vector<sc_object*> children = get_child_objects();
int child_n = children.size();
for ( int child_i = 0; child_i < child_n; child_i++ )
{
sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]);
if ( child_p ) child_p->kill_process(descendants);
}
}
if ( m_unwinding )
{
SC_REPORT_WARNING( SC_ID_PROCESS_ALREADY_UNWINDING_, name() );
return;
}
if ( m_state & ps_bit_zombie )
return;
if ( next_runnable() != 0 )
simcontext()->remove_runnable_method( this );
disconnect_process();
m_throw_status = THROW_KILL;
if ( sc_get_current_process_b() == this )
{
throw sc_unwind_exception( this, false );
}
} |
void sc_method_process::check_for_throws();
void sc_method_process::clear_trigger();
sc_method_process::~sc_method_process();
void sc_method_process::throw_reset( bool async );
bool sc_method_process::trigger_dynamic( sc_event* e );
| 5700b43967b427b60857e11405d8c3b5dfe718bd15f4b9e7d0122dd86842a2c3 | 1,164 |
|
alinous-core | alinous-elastic-db | lib/src_java/alinous.runtime.parallel/SequentialBackgroundJob.cpp | SequentialBackgroundJob::~SequentialBackgroundJob | SequentialBackgroundJob::~SequentialBackgroundJob() throw()
{
ThreadContext *ctx = ThreadContext::getCurentContext();
if(ctx != nullptr){ctx->incGcDenial();}
__releaseRegerences(false, ctx);
if(ctx != nullptr){ctx->decGcDenial();}
} |
bool SequentialBackgroundJob::__init_static_variables();
SequentialBackgroundJob::SequentialBackgroundJob(ThreadContext* ctx);
void SequentialBackgroundJob::__construct_impl(ThreadContext* ctx);
void SequentialBackgroundJob::__releaseRegerences(bool prepare, ThreadContext* ctx);
SequentialBackgroundJob* SequentialBackgroundJob::init(ThreadPool* pool, ThreadContext* ctx);
void SequentialBackgroundJob::addJob(IThreadAction* action, ThreadContext* ctx);
void SequentialBackgroundJob::execLoop(LaunchJoin* launchJoin, ThreadContext* ctx);
void SequentialBackgroundJob::joinAndEnd(ThreadContext* ctx);
Throwable* SequentialBackgroundJob::getLastException(ThreadContext* ctx);
void SequentialBackgroundJob::__cleanUp(ThreadContext* ctx);
bool SequentialBackgroundJob::QueueExecutor::__init_static_variables();
SequentialBackgroundJob::QueueExecutor::QueueExecutor(LaunchJoin* launchJoin, SequentialBackgroundJob* _this, ThreadContext* ctx);
void SequentialBackgroundJob::QueueExecutor::__construct_impl(LaunchJoin* launchJoin, SequentialBackgroundJob* _this, ThreadContext* ctx);
SequentialBackgroundJob::QueueExecutor::~QueueExecutor();
void SequentialBackgroundJob::QueueExecutor::__releaseRegerences(bool prepare, ThreadContext* ctx);
void SequentialBackgroundJob::QueueExecutor::execute(ThreadContext* ctx);
void SequentialBackgroundJob::QueueExecutor::__cleanUp(ThreadContext* ctx);
| f8379764912f5bb74b7493565444c82d232cdc3c313e2d31b44bd6d1eb045f0e | 238 |
|
JTippetts | U3DTerrainEditor | Source/UI/alphabrushselectorui.cpp | AlphaBrushSelectorUI::SetSelected |
void AlphaBrushSelectorUI::SetSelected(AlphaEntry *e)
{
if(selected_ && selected_->element_)
{
DynamicCast<Window>(selected_->element_)->SetImageRect(IntRect(48,0,64,16));
}
selected_=e;
if(e && e->element_)
{
DynamicCast<Window>(e->element_)->SetImageRect(IntRect(160,64,176,80));
}
if(materialBuilder_ && selected_)
{
materialBuilder_->SetAlphaTexture(selected_->tex_);
}
} |
AlphaBrushSelectorUI::AlphaBrushSelectorUI(Context *context);
void AlphaBrushSelectorUI::Construct(TerrainMaterialBuilder *tmb);
void AlphaBrushSelectorUI::PopulateList();
void AlphaBrushSelectorUI::HandleAlphaSelected(StringHash eventType, VariantMap &eventData);
| db93703da261ef9d33dc737ce149a92d4a6cc2d05d9637677344def96c76fc71 | 393 |
|
synesissoftware | Pantheios | test/component/test.component.log.1/test.component.log.1.cpp | test_20 |
static void test_20()
{} |
int main(int argc, char** argv);
static void test_01();
static void test_02();
static void test_03();
static void test_04();
static void test_05();
static void test_06();
static void test_07();
static void test_08();
static void test_09();
static void test_10();
static void test_11();
static void test_12();
static void test_13();
static void test_14();
static void test_15();
static void test_16();
static void test_17();
static void test_18();
static void test_19();
static void test_21();
static void test_22();
static void test_23();
static void test_24();
static void test_25();
static void test_26();
static void test_27();
static void test_28();
static void test_29();
| a3a82a147d6b1452d3aa92174e72d61fec28d16a21cdf58cd304b4766e43b6f6 | 25 |
|
RaminNietzsche | POSFET | src/interface/timetableviewroomsform.cpp |
TimetableViewRoomsForm::~TimetableViewRoomsForm |
TimetableViewRoomsForm::~TimetableViewRoomsForm()
{
saveFETDialogGeometry(this);
QSettings settings(COMPANY, PROGRAM);
settings.setValue(this->metaObject()->className()+QString("/vertical-splitter-state"), verticalSplitter->saveState());
settings.setValue(this->metaObject()->className()+QString("/horizontal-splitter-state"), horizontalSplitter->saveState());
} |
TimetableViewRoomsForm::TimetableViewRoomsForm(QWidget* parent);
void TimetableViewRoomsForm::resizeRowsAfterShow();
void TimetableViewRoomsForm::roomChanged(const QString &roomName);
void TimetableViewRoomsForm::updateRoomsTimetableTable();
void TimetableViewRoomsForm::resizeEvent(QResizeEvent* event);
void TimetableViewRoomsForm::currentItemChanged(QTableWidgetItem* current, QTableWidgetItem* previous);
void TimetableViewRoomsForm::detailActivity(QTableWidgetItem* item);
void TimetableViewRoomsForm::lock();
void TimetableViewRoomsForm::lockTime();
void TimetableViewRoomsForm::lockSpace();
void TimetableViewRoomsForm::lock(bool lockTime, bool lockSpace);
void TimetableViewRoomsForm::help();
| 3dfcfc5690f482d5018f66045d7bd568a011fddd5caf93c372c9a9ba51eda00f | 378 |
|
Canpio | Paddle | paddle/api/Matrix.cpp | Matrix::isGpu |
bool Matrix::isGpu() const {
auto rawPtr = m->mat.get();
return dynamic_cast<paddle::GpuMatrix*>(rawPtr) != nullptr ||
dynamic_cast<paddle::GpuSparseMatrix*>(rawPtr) != nullptr;
} |
Matrix* Matrix::createByPaddleMatrixPtr(void* sharedPtr);
Matrix* Matrix::createZero(size_t height, size_t width, bool useGpu);
Matrix* Matrix::createGpuDenseFromNumpy(float* data, int dim1, int dim2);
float Matrix::get(size_t x, size_t y);
void Matrix::set(size_t x, size_t y, float val);
bool Matrix::isSparse();
SparseValueType Matrix::getSparseValueType();
SparseFormatType Matrix::getSparseFormat();
IntArray Matrix::getSparseRowCols(size_t i);
IntWithFloatArray Matrix::getSparseRowColsVal(size_t i);
FloatArray Matrix::getData();
| 398892358840c89daf4e3c016c4ef83841a8573002aed6824dd3a14e66bd362e | 193 |
|
pombredanne | FastPFor | src/simdunalignedbitpacking.cpp | __SIMD_fastpackwithoutmask22_32 |
static void __SIMD_fastpackwithoutmask22_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out) {
const __m128i *in = reinterpret_cast<const __m128i*>(_in);
__m128i OutReg;
__m128i InReg = _mm_loadu_si128(in);
OutReg = InReg;
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 22));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 12);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 12));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 2);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 2));
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 24));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 14);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 14));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 4);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 4));
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 26));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 16);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 16));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 6);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 6));
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 28));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 18);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 18));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 8);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 8));
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 30));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 20);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 20));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 10);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 10));
_mm_storeu_si128(out, OutReg);
++out;
InReg = _mm_loadu_si128(++in);
OutReg = InReg;
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 22));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 12);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 12));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 2);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 2));
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 24));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 14);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 14));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 4);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 4));
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 26));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 16);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 16));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 6);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 6));
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 28));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 18);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 18));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 8);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 8));
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 30));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 20);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 20));
_mm_storeu_si128(out, OutReg);
++out;
OutReg = _mm_srli_epi32(InReg, 22 - 10);
InReg = _mm_loadu_si128(++in);
OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 10));
_mm_storeu_si128(out, OutReg);
} |
static void SIMD_nullunpacker32(const __m128i * __restrict__ , uint32_t * __restrict__ out);
static void __SIMD_fastpackwithoutmask1_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask2_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask3_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask5_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask6_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask7_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask9_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask10_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask11_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask12_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask13_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask14_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask15_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask17_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask18_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask19_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask20_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask21_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask23_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask24_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask25_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask26_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask27_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask28_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask29_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask30_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask31_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask32_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask4_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask8_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpackwithoutmask16_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack1_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack2_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack3_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack5_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack6_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack7_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack9_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack10_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack11_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack12_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack13_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack14_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack15_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack17_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack18_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack19_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack20_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack21_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack22_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack23_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack24_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack25_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack26_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack27_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack28_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack29_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack30_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack31_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack32_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack4_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack8_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastpack16_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out);
static void __SIMD_fastunpack1_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack2_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack3_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack4_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack5_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack6_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack7_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack8_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack9_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack10_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack11_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack12_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack13_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack14_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack15_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack16_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack17_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack18_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack19_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack20_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack21_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack22_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack23_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack24_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack25_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack26_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack27_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack28_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack29_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack30_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack31_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
static void __SIMD_fastunpack32_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out);
void usimdunpack(const __m128i * __restrict__ in, uint32_t * __restrict__ out, const uint32_t bit);
void usimdpackwithoutmask(const uint32_t * __restrict__ in, __m128i * __restrict__ out, const uint32_t bit);
void usimdpack(const uint32_t * __restrict__ in, __m128i * __restrict__ out, const uint32_t bit);
| 8e74cc07f67a8c3ab260af2b8e3c6462ae77738826b6c345d165a74ee89162ae | 5,154 |
|
ZhangPeike | 3D-Reconstruction-System | apps/umve/build/moc_glwidget.cpp | GLWidget::qt_metacall |
int GLWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QGLWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 3)
qt_static_metacall(this, _c, _id, _a);
_id -= 3;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 3)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 3;
}
return _id;
} | ;
void GLWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a);
const QMetaObject *GLWidget::metaObject();
void *GLWidget::qt_metacast(const char *_clname);
| 4aaf8434b43b5f046ae85f1b21fdb3333a8ccdbd7623c6da8f997c4ed040b0a3 | 471 |
|
Fat-Zer | FreeCAD_sf_master | src/Gui/Tree.cpp | DocumentItem::slotResetEdit | void DocumentItem::slotResetEdit(const Gui::ViewProviderDocumentObject& v)
{
auto tree = getTree();
FOREACH_ITEM_ALL(item)
if(tree->editingItem) {
if(item == tree->editingItem) {
item->setData(0, Qt::BackgroundRole,QVariant());
break;
}
}else if(item->object() == &v)
item->setData(0, Qt::BackgroundRole,QVariant());
END_FOREACH_ITEM
tree->editingItem = 0;
}
| TreeParams::TreeParams();
void TreeParams::onSyncSelectionChanged();
void TreeParams::onCheckBoxesSelectionChanged();
void TreeParams::onDocumentModeChanged();
TreeParams *TreeParams::Instance();
void print();
TimingInfo(FC_DURATION &d);
~TimingInfo();
void stop();
void reset();
DocumentObjectData(DocumentItem *docItem, ViewProviderDocumentObject* vpd);
const char *getTreeName();
void updateChildren(DocumentObjectDataPtr other);
bool updateChildren(bool checkVisibility);
void testStatus(bool resetStatus = false);
void slotChangeIcon();
void slotChangeToolTip(const QString& tip);
void slotChangeStatusTip(const QString& tip);
void restore(Base::XMLReader &reader);
TreeWidgetEditDelegate::TreeWidgetEditDelegate(QObject* parent);
TreeWidget::~TreeWidget();
const char *TreeWidget::getTreeName();
void TreeWidget::selectAll();
bool TreeWidget::isObjectShowable(App::DocumentObject *obj);
void TreeWidget::checkTopParent(App::DocumentObject *&obj, std::string &subname);
void TreeWidget::resetItemSearch();
void TreeWidget::startItemSearch(QLineEdit *edit);
void TreeWidget::itemSearch(const QString &text, bool select);
Gui::Document *TreeWidget::selectedDocument();
void TreeWidget::updateStatus(bool delay);
void TreeWidget::_updateStatus(bool delay);
void TreeWidget::contextMenuEvent (QContextMenuEvent * e);
void TreeWidget::hideEvent(QHideEvent *ev);
void TreeWidget::showEvent(QShowEvent *ev);
void TreeWidget::onCreateGroup();
void TreeWidget::onRelabelObject();
void TreeWidget::onStartEditing();
void TreeWidget::onFinishEditing();
void TreeWidget::onSkipRecompute(bool on);
void TreeWidget::onAllowPartialRecompute(bool on);
void TreeWidget::onMarkRecompute();
void TreeWidget::onRecomputeObject();
DocumentItem *TreeWidget::getDocumentItem(const Gui::Document *doc);
void TreeWidget::selectAllInstances(const ViewProviderDocumentObject &vpd);
TreeWidget *TreeWidget::instance();
std::vector<TreeWidget::SelInfo> TreeWidget::getSelection(App::Document *doc);
void TreeWidget::selectAllLinks(App::DocumentObject *obj);
void TreeWidget::onSearchObjects();
void TreeWidget::onActivateDocument(QAction* active);
Qt::DropActions TreeWidget::supportedDropActions ();
bool TreeWidget::event(QEvent *e);
bool TreeWidget::eventFilter(QObject *, QEvent *ev);
void TreeWidget::keyPressEvent(QKeyEvent *event);
void TreeWidget::mouseDoubleClickEvent (QMouseEvent * event);
void TreeWidget::startDragging();
void TreeWidget::startDrag(Qt::DropActions supportedActions);
QMimeData * TreeWidget::mimeData (const QList<QTreeWidgetItem *> items);
bool TreeWidget::dropMimeData(QTreeWidgetItem *parent, int index,
const QMimeData *data, Qt::DropAction action);
void TreeWidget::dragEnterEvent(QDragEnterEvent * event);
void TreeWidget::dragLeaveEvent(QDragLeaveEvent * event);
void TreeWidget::dragMoveEvent(QDragMoveEvent *event);
void TreeWidget::dropEvent(QDropEvent *event);
void TreeWidget::drawRow(QPainter *painter, const QStyleOptionViewItem &options, const QModelIndex &index);
void TreeWidget::slotNewDocument(const Gui::Document& Doc, bool isMainDoc);
void TreeWidget::slotStartOpenDocument();
void TreeWidget::slotFinishOpenDocument();
void TreeWidget::onReloadDoc();
void TreeWidget::onCloseDoc();
void TreeWidget::slotRenameDocument(const Gui::Document& Doc);
void TreeWidget::slotChangedViewObject(const Gui::ViewProvider& vp, const App::Property &prop);
void TreeWidget::slotTouchedObject(const App::DocumentObject &obj);
void TreeWidget::slotShowHidden(const Gui::Document& Doc);
void TreeWidget::slotRelabelDocument(const Gui::Document& Doc);
void TreeWidget::slotActiveDocument(const Gui::Document& Doc);
UpdateDisabler(QWidget &w, int &blocked);
~UpdateDisabler();
void TreeWidget::onUpdateStatus(void);
void TreeWidget::onItemEntered(QTreeWidgetItem * item);
void TreeWidget::leaveEvent(QEvent *);
void TreeWidget::onPreSelectTimer();
void TreeWidget::onItemCollapsed(QTreeWidgetItem * item);
void TreeWidget::onItemExpanded(QTreeWidgetItem * item);
void TreeWidget::scrollItemToTop();
void TreeWidget::expandSelectedItems(TreeItemMode mode);
void TreeWidget::setupText();
void TreeWidget::syncView(ViewProviderDocumentObject *vp);
void TreeWidget::onShowHidden();
void TreeWidget::onHideInTree();
void TreeWidget::changeEvent(QEvent *e);
void TreeWidget::onItemSelectionChanged ();
static bool isSelectionCheckBoxesEnabled();
void TreeWidget::synchronizeSelectionCheckBoxes();
void TreeWidget::onItemChanged(QTreeWidgetItem *item, int column);
void TreeWidget::onSelectTimer();
void TreeWidget::onSelectionChanged(const SelectionChanges& msg);
TreePanel::TreePanel(const char *name, QWidget* parent);
TreePanel::~TreePanel();
void TreePanel::accept();
bool TreePanel::eventFilter(QObject *obj, QEvent *ev);
void TreePanel::showEditor();
void TreePanel::hideEditor();
void TreePanel::itemSearch(const QString &text);
TreeDockWidget::TreeDockWidget(Gui::Document* pcDocument,QWidget *parent);
TreeDockWidget::~TreeDockWidget();
void TreeWidget::selectLinkedObject(App::DocumentObject *linked);
DocumentItem::DocumentItem(const Gui::Document* doc, QTreeWidgetItem * parent);
DocumentItem::~DocumentItem();
TreeWidget *DocumentItem::getTree();
const char *DocumentItem::getTreeName();
void DocumentItem::slotInEdit(const Gui::ViewProviderDocumentObject& v);
void DocumentItem::slotNewObject(const Gui::ViewProviderDocumentObject& obj);
bool DocumentItem::createNewItem(const Gui::ViewProviderDocumentObject& obj,
QTreeWidgetItem *parent, int index, DocumentObjectDataPtr data);
ViewProviderDocumentObject *DocumentItem::getViewProvider(App::DocumentObject *obj);
void TreeWidget::slotDeleteDocument(const Gui::Document& Doc);
void TreeWidget::slotDeleteObject(const Gui::ViewProviderDocumentObject& view);
void TreeWidget::_slotDeleteObject(const Gui::ViewProviderDocumentObject& view, DocumentItem *deletingDoc);
bool DocumentItem::populateObject(App::DocumentObject *obj);
void DocumentItem::populateItem(DocumentObjectItem *item, bool refresh, bool delay);
int DocumentItem::findRootIndex(App::DocumentObject *childObj);
void TreeWidget::slotChangeObject(
const Gui::ViewProviderDocumentObject& view, const App::Property &prop);
void TreeWidget::updateChildren(App::DocumentObject *obj,
const std::set<DocumentObjectDataPtr> &dataSet, bool propOutput, bool force);
void DocumentItem::slotHighlightObject (const Gui::ViewProviderDocumentObject& obj,
const Gui::HighlightMode& high, bool set, const App::DocumentObject *parent, const char *subname);
static unsigned int countExpandedItem(const QTreeWidgetItem *item);
unsigned int DocumentItem::getMemSize(void);
static void saveExpandedItem(Base::Writer &writer, const QTreeWidgetItem *item);
void DocumentItem::Save (Base::Writer &writer);
void DocumentItem::Restore(Base::XMLReader &reader);
void DocumentItem::restoreItemExpansion(const ExpandInfoPtr &info, DocumentObjectItem *item);
void DocumentItem::slotExpandObject (const Gui::ViewProviderDocumentObject& obj,
const Gui::TreeItemMode& mode, const App::DocumentObject *parent, const char *subname);
void DocumentItem::slotScrollToObject(const Gui::ViewProviderDocumentObject& obj);
void DocumentItem::slotRecomputedObject(const App::DocumentObject &obj);
void DocumentItem::slotRecomputed(const App::Document &, const std::vector<App::DocumentObject*> &objs);
Gui::Document* DocumentItem::document();
void DocumentItem::testStatus(void);
void DocumentItem::setData (int column, int role, const QVariant & value);
void DocumentItem::clearSelection(DocumentObjectItem *exclude);
void DocumentItem::updateSelection(QTreeWidgetItem *ti, bool unselect);
void DocumentItem::updateItemSelection(DocumentObjectItem *item);
App::DocumentObject *DocumentItem::getTopParent(App::DocumentObject *obj, std::string &subname);
DocumentObjectItem *DocumentItem::findItemByObject(
bool sync, App::DocumentObject *obj, const char *subname, bool select);
DocumentObjectItem *DocumentItem::findItem(
bool sync, DocumentObjectItem *item, const char *subname, bool select);
void DocumentItem::selectItems(SelectionReason reason);
void DocumentItem::populateParents(const ViewProvider *vp, ViewParentMap &parentMap);
void DocumentItem::selectAllInstances(const ViewProviderDocumentObject &vpd);
bool DocumentItem::showHidden();
void DocumentItem::setShowHidden(bool show);
bool DocumentItem::showItem(DocumentObjectItem *item, bool select, bool force);
void DocumentItem::updateItemsVisibility(QTreeWidgetItem *item, bool show);
void DocumentItem::updateSelection();
DocumentObjectItem::DocumentObjectItem(DocumentItem *ownerDocItem, DocumentObjectDataPtr data);
DocumentObjectItem::~DocumentObjectItem();
void DocumentObjectItem::restoreBackground();
void DocumentObjectItem::setHighlight(bool set, Gui::HighlightMode high);
const char *DocumentObjectItem::getTreeName();
Gui::ViewProviderDocumentObject* DocumentObjectItem::object();
void DocumentObjectItem::testStatus(bool resetStatus);
void DocumentObjectItem::testStatus(bool resetStatus, QIcon &icon1, QIcon &icon2);
void DocumentObjectItem::displayStatusInfo();
void DocumentObjectItem::setExpandedStatus(bool on);
void DocumentObjectItem::setData (int column, int role, const QVariant & value);
bool DocumentObjectItem::isChildOfItem(DocumentObjectItem* item);
bool DocumentObjectItem::requiredAtRoot(bool excludeSelf);
bool DocumentObjectItem::isLink();
bool DocumentObjectItem::isLinkFinal();
bool DocumentObjectItem::isParentLink();
int DocumentObjectItem::isGroup();
bool DocumentItem::isObjectShowable(App::DocumentObject *obj);
int DocumentObjectItem::isParentGroup();
DocumentObjectItem *DocumentObjectItem::getParentItem();
const char *DocumentObjectItem::getName();
int DocumentObjectItem::getSubName(std::ostringstream &str, App::DocumentObject *&topParent);
App::DocumentObject *DocumentObjectItem::getFullSubName(
std::ostringstream &str, DocumentObjectItem *parent);
void DocumentObjectItem::setCheckState(bool checked);
DocumentItem *DocumentObjectItem::getParentDocument();
DocumentItem *DocumentObjectItem::getOwnerDocument();
TreeWidget *DocumentObjectItem::getTree();
| 869ddfd43375769dff8f84555bc4e2822a18acfddae42581c8e3c10cf9395af4 | 472 |
|
kgudger | PuzDuko | qqwing.cpp | SudokuBoard::rollbackRound |
void SudokuBoard::rollbackRound(int round){
if (logHistory || recordHistory) addHistoryItem(new LogItem(round, LogItem::ROLLBACK));
{for (int i=0; i<BOARD_SIZE; i++){
if (solutionRound[i] == round){
solutionRound[i] = 0;
solution[i] = 0;
}
}}
{for (int i=0; i<POSSIBILITY_SIZE; i++){
if (possibilities[i] == round){
possibilities[i] = 0;
}
}}
while(solveInstructions->size() > 0 && solveInstructions->back()->getRound() == round){
solveInstructions->pop_back();
}
} |
int main(int argc, char *argv[]);
void printVersion();
void printAbout();
void printHelp(char* programName);
SudokuBoard::SudokuBoard();
SudokuBoard::~SudokuBoard();
int SudokuBoard::getGivenCount();
bool SudokuBoard::setPuzzle(int* initPuzzle);
void SudokuBoard::setHighLights(bool printHighLights);
bool SudokuBoard::reset();
SudokuBoard::Difficulty SudokuBoard::getDifficulty();
string SudokuBoard::getDifficultyAsString();
int SudokuBoard::getSingleCount();
int SudokuBoard::getHiddenSingleCount();
int SudokuBoard::getNakedPairCount();
int SudokuBoard::getHiddenPairCount();
int SudokuBoard::getPointingPairTripleCount();
int SudokuBoard::getBoxLineReductionCount();
int SudokuBoard::getGuessCount();
int SudokuBoard::getBacktrackCount();
void SudokuBoard::markRandomPossibility(int round);
void SudokuBoard::shuffleRandomArrays();
void SudokuBoard::clearPuzzle();
bool SudokuBoard::generatePuzzle();
void SudokuBoard::rollbackNonGuesses();
void SudokuBoard::setPrintStyle(PrintStyle ps);
void SudokuBoard::findHighLights();
void SudokuBoard::moveRow(int row, int secondrowpointer);
void SudokuBoard::moveCol(int col, int secondcolpointer);
void SudokuBoard::setPhrase(string* inphraseString);
void SudokuBoard::setRecordHistory(bool recHistory);
void SudokuBoard::setLogHistory(bool logHist);
void SudokuBoard::addHistoryItem(LogItem* l);
void SudokuBoard::printHistory(vector<LogItem*>* v);
void SudokuBoard::printSolveInstructions();
void SudokuBoard::printSolveHistory();
bool SudokuBoard::solve();
bool SudokuBoard::solve(int round);
int SudokuBoard::countSolutions();
int SudokuBoard::countSolutions(int round, bool limitToTwo);
bool SudokuBoard::isSolved();
bool SudokuBoard::isImpossible();
int SudokuBoard::findPositionWithFewestPossibilities();
bool SudokuBoard::guess(int round, int guessNumber);
bool SudokuBoard::singleSolveMove(int round);
bool SudokuBoard::colBoxReduction(int round);
bool SudokuBoard::rowBoxReduction(int round);
bool SudokuBoard::pointingRowReduction(int round);
bool SudokuBoard::pointingColumnReduction(int round);
int SudokuBoard::countPossibilities(int position);
bool SudokuBoard::arePossibilitiesSame(int position1, int position2);
bool SudokuBoard::removePossibilitiesInOneFromTwo(int position1, int position2, int round);
bool SudokuBoard::hiddenPairInColumn(int round);
bool SudokuBoard::hiddenPairInSection(int round);
bool SudokuBoard::hiddenPairInRow(int round);
bool SudokuBoard::handleNakedPairs(int round);
bool SudokuBoard::onlyValueInRow(int round);
bool SudokuBoard::onlyValueInColumn(int round);
bool SudokuBoard::onlyValueInSection(int round);
bool SudokuBoard::onlyPossibilityForCell(int round);
void SudokuBoard::mark(int position, int round, int value);
void SudokuBoard::printPossibilities();
void SudokuBoard::print(int* sudoku);
void SudokuBoard::printPuzzle();
void SudokuBoard::printHighlights();
void SudokuBoard::printSolution();
void SudokuBoard::printPhrase();
LogItem::LogItem(int r, LogType t);
LogItem::LogItem(int r, LogType t, int v, int p);
void LogItem::init(int r, LogType t, int v, int p);
LogItem::~LogItem();
int LogItem::getRound();
LogItem::LogType LogItem::getType();
void LogItem::print();
int getLogCount(vector<LogItem*>* v, LogItem::LogType type);
long getMicroseconds();
void shuffleArray(int* array, int size);
bool readPuzzleFromStdIn(int* puzzle);
static inline int cellToColumn(int cell);
static inline int cellToRow(int cell);
static inline int cellToSection(int cell);
static inline int cellToSectionStartCell(int cell);
static inline int rowToFirstCell(int row);
static inline int columnToFirstCell(int column);
static inline int sectionToFirstCell(int section);
static inline int getPossibilityIndex(int valueIndex, int cell);
static inline int rowColumnToCell(int row, int column);
static inline int sectionToCell(int section, int offset);
| 51f6ec9335853092f4dd432bbd0ed0b47e32a29c18968b669709b0104058e1db | 572 |
|
jkriege2 | JKQtPlotter | lib/jkqtplotter/graphs/jkqtpevaluatedfunctionbase.cpp | JKQTPEvaluatedFunctionGraphBase::setMinPixelPerSample |
void JKQTPEvaluatedFunctionGraphBase::setMinPixelPerSample(double __value)
{
this->minPixelPerSample = __value;
} |
JKQTPEvaluatedFunctionGraphBase::JKQTPEvaluatedFunctionGraphBase(JKQTBasePlotter* parent);
JKQTPEvaluatedFunctionGraphBase::JKQTPEvaluatedFunctionGraphBase(JKQTPlotter* parent);
JKQTPEvaluatedFunctionGraphBase::~JKQTPEvaluatedFunctionGraphBase();
void JKQTPEvaluatedFunctionGraphBase::drawSamplePoints(JKQTPEnhancedPainter& painter, QColor graphColor);
void JKQTPEvaluatedFunctionGraphBase::setMinSamples(const unsigned int &__value);
unsigned int JKQTPEvaluatedFunctionGraphBase::getMinSamples();
void JKQTPEvaluatedFunctionGraphBase::setMaxRefinementDegree(const unsigned int &__value);
unsigned int JKQTPEvaluatedFunctionGraphBase::getMaxRefinementDegree();
void JKQTPEvaluatedFunctionGraphBase::setSlopeTolerance(double __value);
double JKQTPEvaluatedFunctionGraphBase::getSlopeTolerance();
double JKQTPEvaluatedFunctionGraphBase::getMinPixelPerSample();
void JKQTPEvaluatedFunctionGraphBase::setDataCleanupMaxAllowedAngleDegree(double __value);
double JKQTPEvaluatedFunctionGraphBase::getDataCleanupMaxAllowedAngleDegree();
void JKQTPEvaluatedFunctionGraphBase::setDisplaySamplePoints(bool __value);
void JKQTPEvaluatedFunctionGraphBase::createPlotData(bool collectParams);
bool JKQTPEvaluatedFunctionGraphBase::getDisplaySamplePoints();
bool JKQTPEvaluatedFunctionGraphBase::getXMinMax(double &minx, double &maxx, double &smallestGreaterZero);
bool JKQTPEvaluatedFunctionGraphBase::getYMinMax(double &miny, double &maxy, double &smallestGreaterZero);
void JKQTPEvaluatedFunctionGraphBase::collectParameters();
void JKQTPEvaluatedFunctionGraphBase::setParams(const QVector<double> ¶ms);
void JKQTPEvaluatedFunctionGraphBase::setCopiedParams(const double *params, int N);
void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1);
void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1, double p2);
void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1, double p2, double p3);
void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1, double p2, double p3, double p4);
void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1, double p2, double p3, double p4, double p5);
void JKQTPEvaluatedFunctionGraphBase::setParameterColumn(int __value);
int JKQTPEvaluatedFunctionGraphBase::getParameterColumn();
void JKQTPEvaluatedFunctionGraphBase::setParameterColumn(size_t __value);
const QVector<double>& JKQTPEvaluatedFunctionGraphBase::getInternalParams();
QVector<double> &JKQTPEvaluatedFunctionGraphBase::getInternalParams();
bool JKQTPEvaluatedFunctionGraphBase::usesColumn(int c);
JKQTPEvaluatedFunctionGraphBase::PlotFunctorSpec::PlotFunctorSpec();
bool JKQTPEvaluatedFunctionGraphBase::PlotFunctorSpec::isValid();
JKQTPEvaluatedFunctionWithErrorsGraphBase::JKQTPEvaluatedFunctionWithErrorsGraphBase(JKQTBasePlotter *parent);
JKQTPEvaluatedFunctionWithErrorsGraphBase::JKQTPEvaluatedFunctionWithErrorsGraphBase(JKQTPlotter *parent);
JKQTPEvaluatedFunctionWithErrorsGraphBase::~JKQTPEvaluatedFunctionWithErrorsGraphBase();
const QVector<double>& JKQTPEvaluatedFunctionWithErrorsGraphBase::getInternalErrorParams();
QVector<double>& JKQTPEvaluatedFunctionWithErrorsGraphBase::getInternalErrorParams();
bool JKQTPEvaluatedFunctionWithErrorsGraphBase::usesColumn(int c);
void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParams(const QVector<double> &errorParams);
void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParameterColumn(int __value);
int JKQTPEvaluatedFunctionWithErrorsGraphBase::getErrorParameterColumn();
void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParameterColumn(size_t __value);
void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1);
void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1, double p2);
void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1, double p2, double p3);
void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1, double p2, double p3, double p4);
void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1, double p2, double p3, double p4, double p5);
void JKQTPEvaluatedFunctionWithErrorsGraphBase::collectParameters();
| 624d10f4277643f81b9c9efc06ecb94d3d222dc4f9631405d8635a3a08f82f75 | 118 |
|
SelfieSticks | TowerBloCF | The Project/Il2CppOutputProject/Source/il2cppOutput/Il2CppCompilerCalculateTypeValues_25Table.cpp | set_ignoreWhitespace_9 | nline void set_ignoreWhitespace_9(bool value)
{
___ignoreWhitespace_9 = value;
}
| nline void set_localName_0(String_t* value);
nline void set_namespaceUri_1(String_t* value);
nline void set_prefix_2(String_t* value);
nline void set_baseUri_3(String_t* value);
nline void set_pageParent_4(XPathNodeU5BU5D_t47339301* value);
nline void set_pageSibling_5(XPathNodeU5BU5D_t47339301* value);
nline void set_pageSimilar_6(XPathNodeU5BU5D_t47339301* value);
nline void set_doc_7(XPathDocument_t1673143697 * value);
nline void set_lineNumBase_8(int32_t value);
nline void set_linePosBase_9(int32_t value);
nline void set_hashCode_10(int32_t value);
nline void set_localNameHash_11(int32_t value);
nline void set_pageInfo_12(XPathNodePageInfo_t2343388010 * value);
nline void set_pageNum_0(int32_t value);
nline void set_nodeCount_1(int32_t value);
nline void set_pageNext_2(XPathNodeU5BU5D_t47339301* value);
nline void set_scanner_0(XPathScanner_t3283201025 * value);
nline void set_parseDepth_1(int32_t value);
nline void set_temparray1_2(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_temparray2_3(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_temparray3_4(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_temparray4_5(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_temparray5_6(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_temparray6_7(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_temparray7_8(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_temparray8_9(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_temparray9_10(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_functionTable_11(Hashtable_t1853889766 * value);
nline void set_AxesTable_12(Hashtable_t1853889766 * value);
nline void set__objects_0(ArrayList_t2718874744 * value);
nline void set_isKeys_1(bool value);
nline void set_data_0(ArrayList_t2718874744 * value);
nline void set_contents_0(Hashtable_t1853889766 * value);
nline void set_leftOverBytes_0(ByteU5BU5D_t4116647657* value);
nline void set_leftOverBytesCount_1(int32_t value);
nline void set_charsLine_2(CharU5BU5D_t3528271667* value);
nline void set__targetsAtLeast_Desktop_V4_5_2_0(bool value);
nline void set_MASK_0101010101010101_0(uint32_t value);
nline void set_MASK_0011001100110011_1(uint32_t value);
nline void set_MASK_0000111100001111_2(uint32_t value);
nline void set_MASK_0000000011111111_3(uint32_t value);
nline void set_MASK_1111111111111111_4(uint32_t value);
nline void set_hashCodeRandomizer_1(int32_t value);
nline void set_hashCodeDelegate_0(HashCodeOfStringDelegate_t1614268366 * value);
nline void set_nsdecls_0(NamespaceDeclarationU5BU5D_t3609802718* value);
nline void set_lastDecl_1(int32_t value);
nline void set_nameTable_2(XmlNameTable_t71772148 * value);
nline void set_scopeId_3(int32_t value);
nline void set_hashTable_4(Dictionary_2_t2736202052 * value);
nline void set_useHashtable_5(bool value);
nline void set_xml_6(String_t* value);
nline void set_xmlNs_7(String_t* value);
nline void set_IsTextualNodeBitmap_0(uint32_t value);
nline void set_CanReadContentAsBitmap_1(uint32_t value);
nline void set_HasValueBitmap_2(uint32_t value);
nline void set_s_instance_0(RuntimeObject* value);
nline void set_reader_0(XmlTextReaderImpl_t178060594 * value);
nline void set_writeNodeBuffer_0(CharU5BU5D_t3528271667* value);
nline void set_info_0(XPathNodeInfoAtom_t1760358141 * value);
nline void set_idxSibling_1(uint16_t value);
nline void set_idxParent_2(uint16_t value);
nline void set_idxSimilar_3(uint16_t value);
nline void set_posOffset_4(uint16_t value);
nline void set_props_5(uint32_t value);
nline void set_value_6(String_t* value);
nline void set_page_0(XPathNodeU5BU5D_t47339301* value);
nline void set_idx_1(int32_t value);
nline void set_input_0(AstNode_t2514041814 * value);
nline void set_condition_1(AstNode_t2514041814 * value);
nline void set_groupNode_0(AstNode_t2514041814 * value);
nline void set_localname_0(String_t* value);
nline void set_prefix_1(String_t* value);
nline void set_enumSeperatorCharArray_0(CharU5BU5D_t3528271667* value);
nline void set_m_value_0(int32_t value);
nline void set_m_value_0(int64_t value);
nline void set_m_value_0(void* value);
nline void set_Zero_1(intptr_t value);
nline void set_value_0(bool value);
nline void set_has_value_1(bool value);
nline void set_buffer_0(ByteU5BU5D_t4116647657* value);
nline void set_curIndex_1(int32_t value);
nline void set_endIndex_2(int32_t value);
nline void set_hasHalfByteCached_3(bool value);
nline void set_cachedHalfByte_4(uint8_t value);
nline void set_lineNo_0(int32_t value);
nline void set_linePos_1(int32_t value);
nline void set_comparer_0(XPathNavigatorKeyComparer_t2518900029 * value);
nline void set_NodeTypeLetter_1(CharU5BU5D_t3528271667* value);
nline void set_UniqueIdTbl_2(CharU5BU5D_t3528271667* value);
nline void set_ContentKindMasks_3(Int32U5BU5D_t385246372* value);
nline void set_charProperties_2(ByteU5BU5D_t4116647657* value);
nline void set_s_Lock_0(RuntimeObject * value);
nline void set_s_CharProperties_1(ByteU5BU5D_t4116647657* value);
nline void set_impl_3(XmlTextReaderImpl_t178060594 * value);
nline void set_chars_0(CharU5BU5D_t3528271667* value);
nline void set_charPos_1(int32_t value);
nline void set_charsUsed_2(int32_t value);
nline void set_encoding_3(Encoding_t1523322056 * value);
nline void set_appendMode_4(bool value);
nline void set_stream_5(Stream_t1273022909 * value);
nline void set_decoder_6(Decoder_t2204182725 * value);
nline void set_bytes_7(ByteU5BU5D_t4116647657* value);
nline void set_bytePos_8(int32_t value);
nline void set_bytesUsed_9(int32_t value);
nline void set_textReader_10(TextReader_t283511965 * value);
nline void set_lineNo_11(int32_t value);
nline void set_lineStartPos_12(int32_t value);
nline void set_baseUriStr_13(String_t* value);
nline void set_baseUri_14(Uri_t100236324 * value);
nline void set_isEof_15(bool value);
nline void set_isStreamEof_16(bool value);
nline void set_entity_17(RuntimeObject* value);
nline void set_entityId_18(int32_t value);
nline void set_eolNormalized_19(bool value);
nline void set_entityResolvedManually_20(bool value);
nline void set_xmlTextEncoder_3(XmlTextEncoder_t1632274355 * value);
nline void set_U30283A6AF88802AB45989B29549915BEA0F6CD515_0(__StaticArrayInitTypeSizeU3D14_t3517563373 value);
nline void set_U303F4297FCC30D0FD5E420E5D26E7FA711167C7EF_1(int64_t value);
nline void set_U31A39764B112685485A5BA7B2880D878B858C1A7A_2(__StaticArrayInitTypeSizeU3D9_t3218278900 value);
nline void set_U31A84029C80CB5518379F199F53FF08A7B764F8FD_3(__StaticArrayInitTypeSizeU3D3_t3217885684 value);
nline void set_U33BE77BF818331C2D8400FFFFF9FADD3F16AD89AC_4(__StaticArrayInitTypeSizeU3D12_t2710994318 value);
nline void set_U359F5BD34B6C013DEACC784F69C67E95150033A84_5(__StaticArrayInitTypeSizeU3D32_t2711125391 value);
nline void set_U35BC3486B05BA8CF4689C7BDB198B3F477BB4E20C_6(__StaticArrayInitTypeSizeU3D6_t3217689075 value);
nline void set_U36D49C9D487D7AD3491ECE08732D68A593CC2038D_7(__StaticArrayInitTypeSizeU3D9_t3218278900 value);
nline void set_U36F3AD3DC3AF8047587C4C9D696EB68A01FEF796E_8(__StaticArrayInitTypeSizeU3D128_t531529102 value);
nline void set_U38E0EF3D67A3EB1863224EE3CACB424BC2F8CFBA3_9(__StaticArrayInitTypeSizeU3D44_t3517366764 value);
nline void set_U398A44A6F8606AE6F23FE230286C1D6FBCC407226_10(int64_t value);
nline void set_ADDB8526F472C1C6D36DBD5A6E509D973CC34C92_11(__StaticArrayInitTypeSizeU3D12_t2710994318 value);
nline void set_C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_12(__StaticArrayInitTypeSizeU3D32_t2711125391 value);
nline void set_CCEEADA43268372341F81AE0C9208C6856441C04_13(__StaticArrayInitTypeSizeU3D128_t531529102 value);
nline void set_E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_14(int64_t value);
nline void set_EC5842B3154E1AF94500B57220EB9F684BCCC42A_15(__StaticArrayInitTypeSizeU3D32_t2711125391 value);
nline void set_EEAFE8C6E1AB017237567305EE925C976CDB6458_16(__StaticArrayInitTypeSizeU3D256_t1757367633 value);
nline void set_pageCurrent_4(XPathNodeU5BU5D_t47339301* value);
nline void set_pageParent_5(XPathNodeU5BU5D_t47339301* value);
nline void set_idxCurrent_6(int32_t value);
nline void set_idxParent_7(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_method_ptr_0(Il2CppMethodPointer value);
nline void set_invoke_impl_1(intptr_t value);
nline void set_m_target_2(RuntimeObject * value);
nline void set_method_3(intptr_t value);
nline void set_delegate_trampoline_4(intptr_t value);
nline void set_extra_arg_5(intptr_t value);
nline void set_method_code_6(intptr_t value);
nline void set_method_info_7(MethodInfo_t * value);
nline void set_original_method_info_8(MethodInfo_t * value);
nline void set_data_9(DelegateData_t1677132599 * value);
nline void set_method_is_virtual_10(bool value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_textWriter_0(TextWriter_t3478189236 * value);
nline void set_inAttribute_1(bool value);
nline void set_quoteChar_2(Il2CppChar value);
nline void set_attrValue_3(StringBuilder_t * value);
nline void set_cacheAttrValue_4(bool value);
nline void set_xmlCharType_5(XmlCharType_t2277243275 value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_value___2(int32_t value);
nline void set_axisType_0(int32_t value);
nline void set_input_1(AstNode_t2514041814 * value);
nline void set_prefix_2(String_t* value);
nline void set_name_3(String_t* value);
nline void set_nodeType_4(int32_t value);
nline void set_abbrAxis_5(bool value);
nline void set_urn_6(String_t* value);
nline void set_functionType_0(int32_t value);
nline void set_argumentList_1(ArrayList_t2718874744 * value);
nline void set_name_2(String_t* value);
nline void set_prefix_3(String_t* value);
nline void set_ReturnTypes_4(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_type_0(int32_t value);
nline void set_val_1(RuntimeObject * value);
nline void set_opType_1(int32_t value);
nline void set_opnd1_2(AstNode_t2514041814 * value);
nline void set_opnd2_3(AstNode_t2514041814 * value);
nline void set_invertOp_0(OpU5BU5D_t2837398892* value);
nline void set_ftype_0(int32_t value);
nline void set_minargs_1(int32_t value);
nline void set_maxargs_2(int32_t value);
nline void set_argTypes_3(XPathResultTypeU5BU5D_t1515527577* value);
nline void set_xpathExpr_0(String_t* value);
nline void set_xpathExprIndex_1(int32_t value);
nline void set_kind_2(int32_t value);
nline void set_currentChar_3(Il2CppChar value);
nline void set_name_4(String_t* value);
nline void set_prefix_5(String_t* value);
nline void set_stringValue_6(String_t* value);
nline void set_numberValue_7(double value);
nline void set_canBeFunction_8(bool value);
nline void set_xmlCharType_9(XmlCharType_t2277243275 value);
nline void set_delegates_11(DelegateU5BU5D_t1703627840* value);
nline void set_reader_0(XmlReader_t3121518892 * value);
nline void set_state_1(int32_t value);
nline void set_valueOffset_2(int32_t value);
nline void set_isEnd_3(bool value);
nline void set__nt_0(XmlNameTable_t71772148 * value);
nline void set__nsMgr_1(XmlNamespaceManager_t418790500 * value);
nline void set__docTypeName_2(String_t* value);
nline void set__pubId_3(String_t* value);
nline void set__sysId_4(String_t* value);
nline void set__internalSubset_5(String_t* value);
nline void set__xmlLang_6(String_t* value);
nline void set__xmlSpace_7(int32_t value);
nline void set__baseURI_8(String_t* value);
nline void set__encoding_9(Encoding_t1523322056 * value);
nline void set_useAsync_0(bool value);
nline void set_nameTable_1(XmlNameTable_t71772148 * value);
nline void set_xmlResolver_2(XmlResolver_t626023767 * value);
nline void set_lineNumberOffset_3(int32_t value);
nline void set_linePositionOffset_4(int32_t value);
nline void set_conformanceLevel_5(int32_t value);
nline void set_checkCharacters_6(bool value);
nline void set_maxCharactersInDocument_7(int64_t value);
nline void set_maxCharactersFromEntities_8(int64_t value);
nline void set_ignorePIs_10(bool value);
nline void set_ignoreComments_11(bool value);
nline void set_dtdProcessing_12(int32_t value);
nline void set_validationType_13(int32_t value);
nline void set_validationFlags_14(int32_t value);
nline void set_schemas_15(XmlSchemaSet_t266093086 * value);
nline void set_closeInput_16(bool value);
nline void set_isReadOnly_17(bool value);
nline void set_U3CIsXmlResolverSetU3Ek__BackingField_18(bool value);
nline void set_s_enableLegacyXmlSettings_19(Nullable_1_t1819850047 value);
nline void set_laterInitParam_3(LaterInitParam_t1449395818 * value);
nline void set_xmlCharType_4(XmlCharType_t2277243275 value);
nline void set_ps_5(ParsingState_t1780334922 value);
nline void set_parsingFunction_6(int32_t value);
nline void set_nextParsingFunction_7(int32_t value);
nline void set_nextNextParsingFunction_8(int32_t value);
nline void set_nodes_9(NodeDataU5BU5D_t1309219640* value);
nline void set_curNode_10(NodeData_t1817330133 * value);
nline void set_index_11(int32_t value);
nline void set_curAttrIndex_12(int32_t value);
nline void set_attrCount_13(int32_t value);
nline void set_attrHashtable_14(int32_t value);
nline void set_attrDuplWalkCount_15(int32_t value);
nline void set_attrNeedNamespaceLookup_16(bool value);
nline void set_fullAttrCleanup_17(bool value);
nline void set_attrDuplSortingArray_18(NodeDataU5BU5D_t1309219640* value);
nline void set_nameTable_19(XmlNameTable_t71772148 * value);
nline void set_nameTableFromSettings_20(bool value);
nline void set_xmlResolver_21(XmlResolver_t626023767 * value);
nline void set_url_22(String_t* value);
nline void set_normalize_23(bool value);
nline void set_supportNamespaces_24(bool value);
nline void set_whitespaceHandling_25(int32_t value);
nline void set_dtdProcessing_26(int32_t value);
nline void set_entityHandling_27(int32_t value);
nline void set_ignorePIs_28(bool value);
nline void set_ignoreComments_29(bool value);
nline void set_checkCharacters_30(bool value);
nline void set_lineNumberOffset_31(int32_t value);
nline void set_linePositionOffset_32(int32_t value);
nline void set_closeInput_33(bool value);
nline void set_maxCharactersInDocument_34(int64_t value);
nline void set_maxCharactersFromEntities_35(int64_t value);
nline void set_v1Compat_36(bool value);
nline void set_namespaceManager_37(XmlNamespaceManager_t418790500 * value);
nline void set_lastPrefix_38(String_t* value);
nline void set_xmlContext_39(XmlContext_t1618903103 * value);
nline void set_parsingStatesStack_40(ParsingStateU5BU5D_t1980313167* value);
nline void set_parsingStatesStackTop_41(int32_t value);
nline void set_reportedBaseUri_42(String_t* value);
nline void set_reportedEncoding_43(Encoding_t1523322056 * value);
nline void set_dtdInfo_44(RuntimeObject* value);
nline void set_fragmentType_45(int32_t value);
nline void set_fragmentParserContext_46(XmlParserContext_t2544895291 * value);
nline void set_fragment_47(bool value);
nline void set_incReadDecoder_48(IncrementalReadDecoder_t3011954239 * value);
nline void set_incReadState_49(int32_t value);
nline void set_incReadLineInfo_50(LineInfo_t3266778363 value);
nline void set_incReadDepth_51(int32_t value);
nline void set_incReadLeftStartPos_52(int32_t value);
nline void set_incReadLeftEndPos_53(int32_t value);
nline void set_attributeValueBaseEntityId_54(int32_t value);
nline void set_emptyEntityInAttributeResolved_55(bool value);
nline void set_validationEventHandling_56(RuntimeObject* value);
nline void set_onDefaultAttributeUse_57(OnDefaultAttributeUseDelegate_t2911570364 * value);
nline void set_validatingReaderCompatFlag_58(bool value);
nline void set_addDefaultAttributesAndNormalize_59(bool value);
nline void set_stringBuilder_60(StringBuilder_t * value);
nline void set_rootElementParsed_61(bool value);
nline void set_standalone_62(bool value);
nline void set_nextEntityId_63(int32_t value);
nline void set_parsingMode_64(int32_t value);
nline void set_readState_65(int32_t value);
nline void set_lastEntity_66(RuntimeObject* value);
nline void set_afterResetState_67(bool value);
nline void set_documentStartBytePos_68(int32_t value);
nline void set_readValueOffset_69(int32_t value);
nline void set_charactersInDocument_70(int64_t value);
nline void set_charactersFromEntities_71(int64_t value);
nline void set_currentEntities_72(Dictionary_2_t1740447880 * value);
nline void set_disableUndeclaredEntityCheck_73(bool value);
nline void set_outerReader_74(XmlReader_t3121518892 * value);
nline void set_xmlResolverIsSet_75(bool value);
nline void set_Xml_76(String_t* value);
nline void set_XmlNs_77(String_t* value);
nline void set_parseText_dummyTask_78(Task_1_t1685771062 * value);
nline void set_useAsync_0(bool value);
nline void set_inputStream_1(Stream_t1273022909 * value);
nline void set_inputBytes_2(ByteU5BU5D_t4116647657* value);
nline void set_inputByteCount_3(int32_t value);
nline void set_inputbaseUri_4(Uri_t100236324 * value);
nline void set_inputUriStr_5(String_t* value);
nline void set_inputUriResolver_6(XmlResolver_t626023767 * value);
nline void set_inputContext_7(XmlParserContext_t2544895291 * value);
nline void set_inputTextReader_8(TextReader_t283511965 * value);
nline void set_initType_9(int32_t value);
nline void set_type_1(int32_t value);
nline void set_localName_2(String_t* value);
nline void set_prefix_3(String_t* value);
nline void set_ns_4(String_t* value);
nline void set_nameWPrefix_5(String_t* value);
nline void set_value_6(String_t* value);
nline void set_chars_7(CharU5BU5D_t3528271667* value);
nline void set_valueStartPos_8(int32_t value);
nline void set_valueLength_9(int32_t value);
nline void set_lineInfo_10(LineInfo_t3266778363 value);
nline void set_lineInfo2_11(LineInfo_t3266778363 value);
nline void set_quoteChar_12(Il2CppChar value);
nline void set_depth_13(int32_t value);
nline void set_isEmptyOrDefault_14(bool value);
nline void set_entityId_15(int32_t value);
nline void set_xmlContextPushed_16(bool value);
nline void set_nextAttrValueChunk_17(NodeData_t1817330133 * value);
nline void set_schemaType_18(RuntimeObject * value);
nline void set_typedValue_19(RuntimeObject * value);
nline void set_s_None_0(NodeData_t1817330133 * value);
nline void set_xmlSpace_0(int32_t value);
nline void set_xmlLang_1(String_t* value);
nline void set_defaultNamespace_2(String_t* value);
nline void set_previousContext_3(XmlContext_t1618903103 * value);
nline void set_textWriter_1(TextWriter_t3478189236 * value);
nline void set_xmlEncoder_2(XmlTextEncoder_t1632274355 * value);
nline void set_encoding_3(Encoding_t1523322056 * value);
nline void set_formatting_4(int32_t value);
nline void set_indented_5(bool value);
nline void set_indentation_6(int32_t value);
nline void set_indentChar_7(Il2CppChar value);
nline void set_stack_8(TagInfoU5BU5D_t2840723532* value);
nline void set_top_9(int32_t value);
nline void set_stateTable_10(StateU5BU5D_t428546178* value);
nline void set_currentState_11(int32_t value);
nline void set_lastToken_12(int32_t value);
nline void set_base64Encoder_13(XmlTextWriterBase64Encoder_t4259465041 * value);
nline void set_quoteChar_14(Il2CppChar value);
nline void set_curQuoteChar_15(Il2CppChar value);
nline void set_namespaces_16(bool value);
nline void set_specialAttr_17(int32_t value);
nline void set_prefixForXmlNs_18(String_t* value);
nline void set_flush_19(bool value);
nline void set_nsStack_20(NamespaceU5BU5D_t4259279085* value);
nline void set_nsTop_21(int32_t value);
nline void set_nsHashtable_22(Dictionary_2_t2736202052 * value);
nline void set_useNsHashtable_23(bool value);
nline void set_xmlCharType_24(XmlCharType_t2277243275 value);
nline void set_stateName_25(StringU5BU5D_t1281789340* value);
nline void set_tokenName_26(StringU5BU5D_t1281789340* value);
nline void set_stateTableDefault_27(StateU5BU5D_t428546178* value);
nline void set_stateTableDocument_28(StateU5BU5D_t428546178* value);
| 1a1f1f5e899800d35c66013094a9fa11a07ca5c9fa2f3c22a0359495135dfc55 | 86 |
|
correa | domoticz | hardware/I2C.cpp | I2C::bmp_Read_BME_SensorDetails |
void I2C::bmp_Read_BME_SensorDetails()
{
float temperature, pressure;
int humidity;
#ifndef HAVE_LINUX_I2C
#ifndef _DEBUG
_log.Log(LOG_ERROR, "%s: I2C is unsupported on this architecture!...", szI2CTypeNames[m_dev_type]);
return;
#else
_log.Log(LOG_ERROR, "%s: I2C is unsupported on this architecture!... Debug: just adding a value", szI2CTypeNames[m_dev_type]);
#endif
temperature = 21.3f;
pressure = 1021.22f;
humidity = 70;
#else
int fd = i2c_Open(m_ActI2CBus.c_str());
if (fd < 0) {
_log.Log(LOG_ERROR, "%s: Error opening device!...", szI2CTypeNames[m_dev_type]);
return;
}
if (!readBME280All(fd, temperature, pressure, humidity))
{
close(fd);
return;
}
close(fd);
#endif
uint8_t forecast = CalculateForecast(((float)pressure) * 10.0f);
int nforecast = wsbaroforecast_some_clouds;
if (pressure <= 980)
nforecast = wsbaroforecast_heavy_rain;
else if (pressure <= 995)
{
if (temperature > 1)
nforecast = wsbaroforecast_rain;
else
nforecast = wsbaroforecast_snow;
}
else if (pressure >= 1029)
nforecast = wsbaroforecast_sunny;
switch (forecast)
{
case bmpbaroforecast_sunny:
nforecast = wsbaroforecast_sunny;
break;
case bmpbaroforecast_cloudy:
nforecast = wsbaroforecast_cloudy;
break;
case bmpbaroforecast_thunderstorm:
nforecast = wsbaroforecast_heavy_rain;
break;
case bmpbaroforecast_rain:
if (temperature > 1)
nforecast = wsbaroforecast_rain;
else
nforecast = wsbaroforecast_snow;
break;
}
SendTempHumBaroSensorFloat(1, 255, temperature, humidity, pressure, nforecast, "TempHumBaro");
} |
I2C::I2C(const int ID, const _eI2CType DevType, const std::string &Address, const std::string &SerialPort, const int Mode1);
I2C::~I2C();
bool I2C::StartHardware();
bool I2C::StopHardware();
bool I2C::WriteToHardware(const char *pdata, const unsigned char /*length*/);
void I2C::Do_Work();
bool I2C::i2c_test(const char *I2CBusName);
int I2C::i2c_Open(const char *I2CBusName);
void I2C::PCF8574_ReadChipDetails();
int I2C::PCF8574_WritePin(uint8_t pin_number, uint8_t value);
void I2C::MCP23017_Init();
void I2C::MCP23017_ReadChipDetails();
int I2C::MCP23017_WritePin(uint8_t pin_number, uint8_t value);
int I2C::ReadInt(int fd, uint8_t *devValues, uint8_t startReg, uint8_t bytesToRead);
int I2C::WriteCmdAddr(const int fd, const uint8_t CmdAddr, const uint8_t devAction);
int I2C::WriteCmd(int fd, uint8_t devAction);
int I2C::readByteI2C(int fd, uint8_t *byte, uint8_t i2c_addr);
int I2C::writeByteI2C(int fd, uint8_t byte, uint8_t i2c_addr);
int I2C::I2CWriteReg16(int fd, uint8_t reg, uint16_t value);
int I2C::I2CReadReg16(int fd, unsigned char reg, i2c_data *data);
int I2C::HTU21D_checkCRC8(uint16_t data);
int I2C::HTU21D_GetHumidity(int fd, float *Hum);
int I2C::HTU21D_GetTemperature(int fd, float *Temp);
void I2C::HTU21D_ReadSensorDetails();
void I2C::TSL2561_Init();
void I2C::TSL2561_ReadSensorDetails();
int I2C::bmp_Calibration(int fd);
int I2C::bmp_WaitForConversion(int fd);
int I2C::bmp_GetPressure(int fd, double *Pres);
int I2C::bmp_GetTemperature(int fd, double *Temp);
double I2C::bmp_altitude(double p);
double I2C::bmp_qnh(double p, double StationAlt);
double I2C::bmp_ppl_DensityAlt(double PAlt, double Temp);
uint8_t I2C::bmp_CalculateForecast(const float pressure);
uint8_t I2C::CalculateForecast(const float pressure);
void I2C::bmp_Read_BMP_SensorDetails();
bool I2C::readBME280ID(const int fd, int &ChipID, int &Version);
int16_t getShort(uint8_t *data, int index);
uint16_t getUShort(uint8_t *data, int index);
int8_t getChar(uint8_t *data, int index);
uint8_t getUChar(uint8_t *data, int index);
bool I2C::readBME280All(const int fd, float &temp, float &pressure, int &humidity);
| f447189bdf03aabd3f6aa3e5e6da6d79333ae58c3ab66f4e3345eeb575b8da8c | 1,578 |
|
RaisingTheDerp | raisingthebar | root/engine/net_ws.cpp | NET_ThreadUnlock |
void NET_ThreadUnlock( void )
{
#if defined( _WIN32 )
if ( use_thread && net_thread_initialized )
{
LeaveCriticalSection( &net_cs );
}
#endif
} |
void NET_ThreadLock( void );
void NetadrToSockadr (netadr_t *a, struct sockaddr *s);
void SockadrToNetadr (struct sockaddr *s, netadr_t *a);
unsigned short NET_HostToNetShort( unsigned short us_in );
unsigned short NET_NetToHostShort( unsigned short us_in );
qboolean NET_CompareAdr (netadr_t a, netadr_t b);
qboolean NET_CompareClassBAdr (netadr_t a, netadr_t b);
qboolean NET_IsReservedAdr (netadr_t a);
qboolean NET_CompareBaseAdr (netadr_t a, netadr_t b);
const char *NET_AdrToString (netadr_t a);
const char *NET_BaseAdrToString (netadr_t a);
qboolean NET_StringToSockaddr ( const char *s, struct sockaddr *sadr );
qboolean NET_StringToAdr ( const char *s, netadr_t *a);
qboolean NET_IsLocalAddress (netadr_t adr);
char *NET_ErrorString (int code);
char *NET_ErrorString (int code);
void NET_TransferRawData( sizebuf_t *msg, unsigned char *pStart, int nSize );
qboolean NET_GetLoopPacket (netsrc_t sock, netadr_t *in_from, sizebuf_t *msg );
void NET_SendLoopPacket (netsrc_t sock, int length, void *data, netadr_t to);
void NET_RemoveFromPacketList(packetlag_t *pPacket);
int NET_CountLaggedList( packetlag_t *pList );
void NET_ClearLaggedList(packetlag_t *pList);
void NET_AddToLagged(netsrc_t sock, packetlag_t *pList, packetlag_t *pPacket, netadr_t *net_from, sizebuf_t messagedata, float timestamp );
void NET_AdjustLag( void );
qboolean NET_LagPacket (qboolean newdata, netsrc_t sock, netadr_t *from, sizebuf_t *data);
CSplitPacketEntry();
void NET_DiscardStaleSplitpackets( void );
CSplitPacketEntry *NET_FindOrCreateSplitPacketEntry( netadr_t *from );
qboolean NET_GetLong( netadr_t *from, byte *pData, int size, int *outSize );
qboolean NET_QueuePacket (netsrc_t sock);
int NET_Sleep( void );
DWORD NET_ThreadFunc( LPVOID pv );
void NET_StartThread( void );
void NET_StopThread( void );
void *net_malloc( size_t size );
net_messages_t *NET_AllocMsg( int size );
void NET_FreeMsg( net_messages_t *pmsg );
qboolean NET_GetPacket (netsrc_t sock);
void NET_AllocateQueues( void );
void NET_FlushQueues( void );
int NET_SendTo( bool verbose, SOCKET s, const char FAR * buf, int len, int flags, const struct sockaddr FAR * to, int tolen );
char const *NET_GetDebugFilename( char const *prefix );
void NET_StorePacket( char const *filename, byte const *buf, int len );
char const *NET_GetPlayerNameForAdr( netadr_t *adr );
int NET_SendLong( netsrc_t sock, SOCKET s, const char FAR * buf, int len, int flags, const struct sockaddr FAR * to, int tolen );
void NET_SendPacket (netsrc_t sock, int length, void *data, netadr_t to);
int NET_IPSocket ( const char *net_interface, int& port);
void NET_OpenIP (void);
char const *NET_GetHostName();
void NET_GetLocalAddress (void);
int NET_IsConfigured( void );
void NET_Config (qboolean multiplayer);
void NET_Init ();
void NET_ClearLagData( qboolean bClient, qboolean bServer );
void NET_Shutdown (void);
| 0e2919b61b2e5e6f08fcb9a2e5d922fbf1b329e4ef91af981129512471af027a | 149 |
|
WNProject | WNFramework | externals/librocket/Source/Core/Element.cpp | Element::ReleaseDeletedElements |
void Element::ReleaseDeletedElements() {
for (size_t i = 0; i < active_children.size(); i++) {
active_children[i]->ReleaseDeletedElements();
}
ReleaseElements(deleted_children);
active_children = children;
} | bool operator();
bool operator();
Element::Element(Core::Context* _context, const String& _tag);
Element::~Element();
void Element::Update();
void Element::Render();
Element* Element::Clone();
void Element::SetClass(const String& class_name, bool activate);
bool Element::IsClassSet(const String& class_name);
void Element::SetClassNames(const String& class_names);
String Element::GetClassNames();
StyleSheet* Element::GetStyleSheet();
const ElementDefinition* Element::GetDefinition();
String Element::GetAddress(bool include_pseudo_classes);
Vector2f Element::GetRelativeOffset(Box::Area area);
Vector2f Element::GetAbsoluteOffset(Box::Area area);
void Element::SetClientArea(Box::Area _client_area);
Box::Area Element::GetClientArea();
void Element::SetBox(const Box& box);
void Element::AddBox(const Box& box);
const Box& Element::GetBox(int index);
int Element::GetNumBoxes();
float Element::GetBaseline();
bool Element::IsPointWithinElement(const Vector2f& point);
bool Element::IsVisible();
float Element::GetZIndex();
FontFaceHandle* Element::GetFontFaceHandle();
bool Element::SetProperty(const String& name, const String& value);
void Element::RemoveProperty(const String& name);
bool Element::SetProperty(const String& name, const Property& property);
const Property* Element::GetProperty(const String& name);
const Property* Element::GetLocalProperty(const String& name);
float Element::ResolveProperty(const String& name, float base_value);
float Element::ResolveProperty(const Property* property, float base_value);
void Element::GetOverflow(int* overflow_x, int* overflow_y);
int Element::GetPosition();
int Element::GetFloat();
int Element::GetDisplay();
int Element::GetWhitespace();
const Property* Element::GetLineHeightProperty();
int Element::GetTextAlign();
int Element::GetTextTransform();
const Property* Element::GetVerticalAlignProperty();
void Element::SetPseudoClass(const String& pseudo_class, bool activate);
bool Element::IsPseudoClassSet(const String& pseudo_class);
bool Element::ArePseudoClassesSet(const PseudoClassList& pseudo_classes);
const PseudoClassList& Element::GetActivePseudoClasses();
Variant* Element::GetAttribute(const String& name);
bool Element::HasAttribute(const String& name);
void Element::RemoveAttribute(const String& name);
Element* Element::GetFocusLeafNode();
DocumentContext* Element::GetContext();
void Element::SetAttributes(const ElementAttributes* _attributes);
int Element::GetNumAttributes();
const String& Element::GetTagName();
const String& Element::GetId();
void Element::SetId(const String& _id);
float Element::GetAbsoluteLeft();
float Element::GetAbsoluteTop();
float Element::GetClientLeft();
float Element::GetClientTop();
float Element::GetClientWidth();
float Element::GetClientHeight();
Element* Element::GetOffsetParent();
float Element::GetOffsetLeft();
float Element::GetOffsetTop();
float Element::GetOffsetWidth();
float Element::GetOffsetHeight();
float Element::GetScrollLeft();
void Element::SetScrollLeft(float scroll_left);
float Element::GetScrollTop();
void Element::SetScrollTop(float scroll_top);
float Element::GetScrollWidth();
float Element::GetScrollHeight();
ElementStyle* Element::GetStyle();
ElementDocument* Element::GetOwnerDocument();
Element* Element::GetParentNode();
Element* Element::GetNextSibling();
Element* Element::GetPreviousSibling();
Element* Element::GetFirstChild();
Element* Element::GetLastChild();
Element* Element::GetChild(int index);
int Element::GetNumChildren(bool include_non_dom_elements);
void Element::GetInnerRML(String& content);
String Element::GetInnerRML();
void Element::SetInnerRML(const String& rml);
bool Element::Focus();
void Element::Blur();
void Element::Click();
void Element::ScrollIntoView(bool align_with_top);
void Element::AppendChild(Element* child, bool dom_element);
void Element::InsertBefore(Element* child, Element* adjacent_element);
bool Element::RemoveChild(Element* child);
bool Element::HasChildNodes();
Element* Element::GetElementById(const String& _id);
void Element::GetElementsByTagName(ElementList& elements, const String& _tag);
EventDispatcher* Element::GetEventDispatcher();
ElementBackground* Element::GetElementBackground();
ElementBorder* Element::GetElementBorder();
ElementDecoration* Element::GetElementDecoration();
ElementScroll* Element::GetElementScroll();
int Element::GetClippingIgnoreDepth();
bool Element::IsClippingEnabled();
RenderInterface* Element::GetRenderInterface();
void Element::SetInstancer(ElementInstancer* _instancer);
void Element::ForceLocalStackingContext();
void Element::OnAttributeChange(const AttributeNameList& changed_attributes);
void Element::OnPropertyChange(const PropertyNameList& changed_properties);
void Element::OnChildAdd(Element* child);
void Element::OnChildRemove(Element* child);
void Element::UpdateLayout();
void Element::DirtyLayout();
void Element::LockLayout(bool lock);
bool Element::IsLayoutDirty();
void Element::DirtyFont();
void Element::OnReferenceDeactivate();
void Element::ProcessEvent(Event& event);
void Element::GetRML(String& content);
void Element::SetParent(Element* _parent);
void Element::ReleaseElements(ElementList& released_elements);
void Element::DirtyOffset();
void Element::UpdateOffset();
void Element::BuildLocalStackingContext();
void Element::BuildStackingContext(ElementList* new_stacking_context);
void Element::DirtyStackingContext();
void Element::DirtyStructure();
| 332b97c6316a0152fe80dfa7b6cc677c3d07d4edd210a73e60ef6aae2a41f172 | 221 |
|
AwkwardDev | TrilliumEMU | dep/g3dlite/source/CollisionDetection.cpp | CollisionDetection::penetrationDepthForFixedSphereFixedBox |
float CollisionDetection::penetrationDepthForFixedSphereFixedBox(
const Sphere& sphere,
const Box& box,
Array<Vector3>& contactPoints,
Array<Vector3>& contactNormals) {
contactPoints.resize(0, DONT_SHRINK_UNDERLYING_ARRAY);
contactNormals.resize(0, DONT_SHRINK_UNDERLYING_ARRAY);
Vector3 halfExtent(box.extent(0), box.extent(1), box.extent(2));
halfExtent *= 0.5f;
CoordinateFrame boxFrame;
box.getLocalFrame(boxFrame);
Vector3 center = boxFrame.pointToObjectSpace(sphere.center);
Vector3 distOutsideBox;
Vector3 centerRegion;
Vector3 constant, variable;
int numNonZero = 0;
for (int a = 0; a < 3; ++a) {
float distanceFromLow = -halfExtent[a] - center[a];
float distanceFromHigh = center[a] - halfExtent[a];
if (fabsf(distanceFromLow) < fabsf(distanceFromHigh)) {
distOutsideBox[a] = distanceFromLow;
} else {
distOutsideBox[a] = distanceFromHigh;
}
if (distanceFromLow < 0.0) {
if (distanceFromHigh < 0.0) {
centerRegion[a] = 0.0;
variable[a] = 1.0;
} else {
centerRegion[a] = 1.0;
constant[a] = halfExtent[a];
++numNonZero;
}
} else if (distanceFromHigh < 0.0) {
centerRegion[a] = -1.0;
constant[a] = -halfExtent[a];
++numNonZero;
} else {
debugAssertM(false,
"distanceFromLow and distanceFromHigh cannot both be positive");
}
}
float d2 = Vector3::zero().max(distOutsideBox).squaredMagnitude();
if (d2 > square(sphere.radius)) {
return -1;
}
double depth = -1;
switch (numNonZero) {
case 3:
contactNormals.append(boxFrame.normalToWorldSpace(constant - center));
contactPoints.append(boxFrame.pointToWorldSpace(constant));
depth = sphere.radius - sqrt(d2);
break;
case 2:
{
Line line = Line::fromPointAndDirection(constant, variable);
depth = sphere.radius - sqrt(d2);
Vector3 X = line.closestPoint(center);
contactNormals.append(boxFrame.normalToWorldSpace(X - center).direction());
contactPoints.append(boxFrame.pointToWorldSpace(X));
}
break;
case 1:
{
Vector3 N = boxFrame.normalToWorldSpace(-centerRegion);
contactNormals.append(N);
depth = sphere.radius - sqrtf(d2);
contactPoints.append(sphere.center + N * (sphere.radius - depth));
}
break;
case 0:
contactPoints.append(sphere.center);
if (distOutsideBox.x > distOutsideBox.y) {
if (distOutsideBox.x > distOutsideBox.z) {
if (center.x > 0) {
contactNormals.append(boxFrame.normalToWorldSpace(-Vector3::unitX()));
} else {
contactNormals.append(boxFrame.normalToWorldSpace(Vector3::unitX()));
}
depth = -distOutsideBox.x;
} else {
goto ZAXIS;
}
} else if (distOutsideBox.y > distOutsideBox.z) {
if (center.y > 0) {
contactNormals.append(boxFrame.normalToWorldSpace(-Vector3::unitY()));
} else {
contactNormals.append(boxFrame.normalToWorldSpace(Vector3::unitY()));
}
depth = -distOutsideBox.y;
} else {
ZAXIS:
if (center.z > 0) {
contactNormals.append(boxFrame.normalToWorldSpace(-Vector3::unitZ()));
} else {
contactNormals.append(boxFrame.normalToWorldSpace(Vector3::unitZ()));
}
depth = -distOutsideBox.z;
}
break;
default:
debugAssertM(false, "Fell through switch");
break;
}
return depth;
} | tatic bool planeBoxOverlap(const Vector3& normal, const Vector3& vert, const Vector3& maxbox);
ool CollisionDetection::fixedSolidBoxIntersectsFixedTriangle(
const AABox& box, const Triangle& tri);
| 409c66418df2dcd00996868af476c11121541c6859d3d675d5aff031c472d6ce | 4,740 |
|
UCI-CARL | CARLsim4 | carlsim/test/interface.cpp |
TEST |
TEST(Interface, setWeightDeath) {
::testing::FLAGS_gtest_death_test_style = "threadsafe";
CARLsim* sim = new CARLsim("Interface.setWeightDeath",CPU_MODE,SILENT,1,42);
int g1=sim->createGroup("excit", Grid3D(10,10,1), EXCITATORY_NEURON);
sim->setNeuronParameters(g1, 0.02f, 0.2f,-65.0f,8.0f);
int c1=sim->connect(g1, g1, "full", RangeWeight(0.01), 1.0f, RangeDelay(1));
EXPECT_DEATH({sim->setWeight(c1, 0, 0, 0.1, false);},"");
sim->setConductances(true);
sim->setupNetwork();
sim->runNetwork(0,20);
EXPECT_DEATH({sim->setWeight(c1+1, 0, 0, 0.1, false);},"");
EXPECT_DEATH({sim->setWeight(-1, 0, 0, 0.1, false);},"");
EXPECT_DEATH({sim->setWeight(0, -1, 0, 0.1, false);},"");
EXPECT_DEATH({sim->setWeight(0, 101, 0, 0.1, false);},"");
EXPECT_DEATH({sim->setWeight(0, 0, -1, 0.1, false);},"");
EXPECT_DEATH({sim->setWeight(0, 0,101, 0.1, false);},"");
EXPECT_DEATH({sim->setWeight(0, 0, 0, -1.0, false);},"");
if (sim!=NULL)
delete sim;
} | void connect(CARLsim* net, int srcGrp, int i, int destGrp, int j, float& weight, float& maxWt, float& delay,
bool& connected);
TEST(Interface, connectDeath);
TEST(Interface, connectCompartmentsDeath);
TEST(Interface, createGroupDeath);
TEST(Interface, createSpikeGeneratorGroupDeath);
TEST(Interface, getGroupGrid3DDeath);
TEST(Interface, getNeuronLocation3DDeath);
TEST(Interface, loggerDeath);
TEST(Interface, biasWeightsDeath);
TEST(Interface, scaleWeightsDeath);
TEST(Interface, getDelayRangeDeath);
TEST(Interface, getWeightRangeDeath);
TEST(Interface, setConductancesDeath);
TEST(Interface, setExternalCurrentDeath);
TEST(Interface, setHomeostasisDeath);
TEST(Interface, setNeuronParametersDeath);
TEST(Interface, setDefaultConductanceTimeConstants);
TEST(Interface, CARLsimState);
TEST(Interface, setDefaultSTDPparamsDeath);
TEST(Interface, setSTDPDeath);
| 8d43a4bc7b30fa151534eab963f0a9266d4a674cf5fe789caee80c40e01945d4 | 1,002 |
|
whdlgp | ARMv6m_Simulator | tests/branchInstrTest.cpp | test_bBGT_Taken2 |
void test_bBGT_Taken2()
{
printf (" %s \n", __FUNCTION__);
setInitialRegisterValues();
clearZero(); setNegative(); setOverflow();
emitInstruction16("1101cccciiiiiiii", COND_GT, 0);
setExpectedXPSRflags("zNV");
setExpectedRegisterValue(PC, INITIAL_PC + 4);
} |
void test_bBEQ_NotTaken();
void test_bBEQ_Taken();
void test_bBNE_NotTaken();
void test_bBNE_Taken();
void test_bBCS_NotTaken();
void test_bBCS_Taken();
void test_bBCC_NotTaken();
void test_bBCC_Taken();
void test_bBMI_NotTaken();
void test_bBMI_Taken();
void test_bBPL_NotTaken();
void test_bBPL_Taken();
void test_bBVS_NotTaken();
void test_bBVS_Taken();
void test_bBVC_NotTaken();
void test_bBVC_Taken();
void test_bBHI_NotTaken();
void test_bBHI_Taken();
void test_bBLS_NotTaken();
void test_bBLS_Taken();
void test_bBGE_NotTaken();
void test_bBGE_Taken1();
void test_bBGE_Taken2();
void test_bBLT_NotTaken();
void test_bBLT_Taken1();
void test_bBLT_Taken2();
void test_bBGT_NotTaken();
void test_bBGT_Taken1();
void test_bBLE_NotTaken();
void test_bBLE_Taken1();
void test_bBLE_Taken2();
void test_bBEQ_TakenWithLargestPositiveOffset();
void test_bBEQ_TakenWithLargesNegativeOffset();
void test_bBAL_ZeroOffset();
void test_bBAL_LargestPositiveOffset();
void test_bBAL_LargestNegativeOffset();
| fe24b369c2554081b7a4892bfd07f3996978980f89f02fa9a2b399fc05772e66 | 290 |
|
FakelsHub | sfall | sfall/Modules/Movies.cpp | __declspec |
static void __declspec(naked) gmovie_play_hook() {
__asm {
push ecx;
call fo::funcoffs::get_input_;
mov ecx, eax;
call PlayMovieLoop;
pop ecx;
retn;
} | HRESULT __stdcall TerminateDevice(DWORD_PTR dwID);
HRESULT __stdcall QueryInterface(const IID &riid, void** ppvObject);
HRESULT __stdcall InitializeDevice(DWORD_PTR dwUserID, VMR9AllocationInfo *lpAllocInfo, DWORD *lpNumBuffers);
HRESULT __stdcall GetSurface(DWORD_PTR dwUserID, DWORD surfaceIndex, DWORD surfaceFlags, IDirect3DSurface9 **lplpSurface);
HRESULT __stdcall StartPresenting(DWORD_PTR dwUserID);
HRESULT __stdcall StopPresenting(DWORD_PTR dwUserID);
HRESULT __stdcall PresentImage(DWORD_PTR dwUserID, VMR9PresentationInfo *lpPresInfo);
CAllocator();
ULONG __stdcall AddRef();
ULONG __stdcall Release();
HRESULT __stdcall AdviseNotify(IVMRSurfaceAllocatorNotify9 *lpIVMRSurfAllocNotify);
bool IsInitialized();
static void PlayMovie(sDSTexture* movie);
static void StopMovie();
DWORD FreeMovie(sDSTexture* movie);
static void BreakMovie();
DWORD CreateDSGraph(wchar_t* path, sDSTexture* movie);
static DWORD __fastcall PlayMovieLoop(long kCode);
static void __declspec(naked);
static void __stdcall PreparePlayMovie();
static void __declspec(naked);
static DWORD __fastcall PrepareLoadMovie(const DWORD id);
static void __stdcall PlayMovieRestore();
static void __declspec(naked);
static void __declspec(naked);
static void __declspec(naked);
static void __declspec(naked);
static void __declspec(naked);
void SkipOpeningMoviesPatch();
static __declspec(naked);
bool Movies::DirectShowMovies();
void Movies::init();
void Movies::exit();
| 36830bad05e6b45cd594d0452efbc44915ed180f902b98817d3e589721fce1c5 | 169 |
|
keera-studios | hsQt | qws/src/gui/QGraphicsItemGroup.cpp |
QTCEXPORT |
QTCEXPORT(int, qtc_QGraphicsItemGroup_unSetUserMethod)(void * evt_obj, int udm_typ, int evt_typ) {
void * te = evt_obj;
return (int) ((DhQGraphicsItemGroup*)te)->unSetDynamicQHandlerud(udm_typ, evt_typ);
} |
QTCEXPORT(void*,qtc_QGraphicsItemGroup);
QTCEXPORT(void*,qtc_QGraphicsItemGroup1);
QTCEXPORT(void*,qtc_QGraphicsItemGroup1_graphicstextitem);
QTCEXPORT(void*,qtc_QGraphicsItemGroup2);
QTCEXPORT(void*,qtc_QGraphicsItemGroup2_graphicstextitem);
QTCEXPORT(void,qtc_QGraphicsItemGroup_addToGroup);
QTCEXPORT(void,qtc_QGraphicsItemGroup_addToGroup_graphicstextitem);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_boundingRect);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_boundingRect_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_boundingRect_qth);
QTCEXPORT(void,qtc_QGraphicsItemGroup_boundingRect_qth_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_isObscuredBy);
QTCEXPORT(int,qtc_QGraphicsItemGroup_isObscuredBy_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_isObscuredBy_graphicstextitem);
QTCEXPORT(int,qtc_QGraphicsItemGroup_isObscuredBy_graphicstextitem_h);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_opaqueArea);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_opaqueArea_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_paint);
QTCEXPORT(void,qtc_QGraphicsItemGroup_paint1);
QTCEXPORT(void,qtc_QGraphicsItemGroup_paint1_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_removeFromGroup);
QTCEXPORT(void,qtc_QGraphicsItemGroup_removeFromGroup_graphicstextitem);
QTCEXPORT(int,qtc_QGraphicsItemGroup_type);
QTCEXPORT(int,qtc_QGraphicsItemGroup_type_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_finalizer);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_getFinalizer);
QTCEXPORT(void,qtc_QGraphicsItemGroup_finalizer1);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_getFinalizer1);
QTCEXPORT(void,qtc_QGraphicsItemGroup_delete);
QTCEXPORT(void,qtc_QGraphicsItemGroup_delete1);
QTCEXPORT(void,qtc_QGraphicsItemGroup_addToIndex);
QTCEXPORT(void,qtc_QGraphicsItemGroup_advance);
QTCEXPORT(void,qtc_QGraphicsItemGroup_advance_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem_graphicstextitem);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem_graphicstextitem_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem1);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem1_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem1_graphicstextitem);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem1_graphicstextitem_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithPath);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithPath_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithPath1);
QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithPath1_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_contains);
QTCEXPORT(int,qtc_QGraphicsItemGroup_contains_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_contains_qth);
QTCEXPORT(int,qtc_QGraphicsItemGroup_contains_qth_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_contextMenuEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_contextMenuEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_dragEnterEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_dragEnterEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_dragLeaveEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_dragLeaveEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_dragMoveEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_dragMoveEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_dropEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_dropEvent_h);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_extension);
QTCEXPORT(void,qtc_QGraphicsItemGroup_focusInEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_focusInEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_focusOutEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_focusOutEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverEnterEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverEnterEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverLeaveEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverLeaveEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverMoveEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverMoveEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_inputMethodEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_inputMethodEvent_h);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_inputMethodQuery);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_inputMethodQuery_h);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_itemChange);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_itemChange_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_keyPressEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_keyPressEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_keyReleaseEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_keyReleaseEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseDoubleClickEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseDoubleClickEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseMoveEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseMoveEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_mousePressEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_mousePressEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseReleaseEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseReleaseEvent_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_prepareGeometryChange);
QTCEXPORT(void,qtc_QGraphicsItemGroup_removeFromIndex);
QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEvent);
QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEvent_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEventFilter);
QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEventFilter_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEventFilter_graphicstextitem);
QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEventFilter_graphicstextitem_h);
QTCEXPORT(void,qtc_QGraphicsItemGroup_setExtension);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_shape);
QTCEXPORT(void*,qtc_QGraphicsItemGroup_shape_h);
QTCEXPORT(int,qtc_QGraphicsItemGroup_supportsExtension);
QTCEXPORT(void,qtc_QGraphicsItemGroup_wheelEvent);
QTCEXPORT(void,qtc_QGraphicsItemGroup_wheelEvent_h);
QTCEXPORT(void, qtc_QGraphicsItemGroup_userMethod);
QTCEXPORT(void*, qtc_QGraphicsItemGroup_userMethodVariant);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setUserMethod);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setUserMethodVariant);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler);
QTCEXPORT(int, qtc_QGraphicsItemGroup_unSetHandler);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler1);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler2);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler3);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler4);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler5);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler6);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler7);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler8);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler9);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler10);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler11);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler12);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler13);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler14);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler15);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler16);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler17);
QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler18);
| e0937c5c8b3f8838407e592fbb6f63b7f0379ffc054ace56fedeb04c33e49e7a | 210 |
|
goodwinxp | Yorozuya | YorozuyaGSLib/source/CPlayerDetail.cpp | CPlayerSendMsg_MovePortal872_wrapper | void CPlayerSendMsg_MovePortal872_wrapper(struct CPlayer* _this, char byRet, char byMapIndex, char byPotalIndex, float* pfStartPos, bool bEqualZone)
{
CPlayerSendMsg_MovePortal872_user(_this, byRet, byMapIndex, byPotalIndex, pfStartPos, bEqualZone, CPlayerSendMsg_MovePortal872_next);
} | void CPlayerAddDalant2_wrapper(struct CPlayer* _this, unsigned int dwPush, bool bApply);
void CPlayerAddGold4_wrapper(struct CPlayer* _this, unsigned int dwPush, bool bApply);
void CPlayerAlterDalant6_wrapper(struct CPlayer* _this, long double dDalant);
void CPlayerAlterExp8_wrapper(struct CPlayer* _this, long double dAlterExp, bool bReward, bool bUseExpRecoverItem, bool bUseExpAdditionItem);
void CPlayerAlterExp_Animus10_wrapper(struct CPlayer* _this, int64_t nAlterExp);
void CPlayerAlterExp_Potion12_wrapper(struct CPlayer* _this, long double dAlterExp);
void CPlayerAlterFP_Animus14_wrapper(struct CPlayer* _this, int nNewFP);
void CPlayerAlterGold16_wrapper(struct CPlayer* _this, long double dGold);
void CPlayerAlterHP_Animus18_wrapper(struct CPlayer* _this, int nNewHP);
void CPlayerAlterMaxLevel20_wrapper(struct CPlayer* _this, char byMaxLevel);
void CPlayerAlterMode_Animus22_wrapper(struct CPlayer* _this, char byMode);
void CPlayerAlterPvPCashBag24_wrapper(struct CPlayer* _this, long double dAlter, PVP_MONEY_ALTER_TYPE IOCode);
void CPlayerAlterPvPPoint26_wrapper(struct CPlayer* _this, long double dAlter, PVP_ALTER_TYPE AlterType, unsigned int dwDstSerial);
void CPlayerAlterPvpPointLeak28_wrapper(struct CPlayer* _this, long double dAlter);
void CPlayerAlterSec30_wrapper(struct CPlayer* _this);
bool CPlayerApplyEquipItemEffect32_wrapper(struct CPlayer* _this, int iItemEffectCode, bool bEquip);
void CPlayerApplySetItemEffect34_wrapper(struct CPlayer* _this, struct si_interpret* pSI, unsigned int dwSetItem, char bySetItemNum, char bySetEffectNum, bool bSetEffect);
int CPlayerAttackableHeight36_wrapper(struct CPlayer* _this);
void CPlayerAutoCharge_Booster38_wrapper(struct CPlayer* _this);
void CPlayerAutoRecover40_wrapper(struct CPlayer* _this);
void CPlayerAutoRecover_Animus42_wrapper(struct CPlayer* _this);
void CPlayerBilling_Logout44_wrapper(struct CPlayer* _this);
void CPlayerBreakCloakBooster46_wrapper(struct CPlayer* _this);
void CPlayerctor_CPlayer48_wrapper(struct CPlayer* _this);
long double CPlayerCalPvpCashPoint50_wrapper(struct CPlayer* _this, int nDstLv, int nSrcLv, char* pSrcClass);
void CPlayerCalPvpTempCash52_wrapper(struct CPlayer* _this, struct CPlayer* pDier, char byKillerObjID);
void CPlayerCalcAddPointByClass54_wrapper(struct CPlayer* _this);
uint16_t CPlayerCalcCurFPRate56_wrapper(struct CPlayer* _this);
uint16_t CPlayerCalcCurHPRate58_wrapper(struct CPlayer* _this);
uint16_t CPlayerCalcCurSPRate60_wrapper(struct CPlayer* _this);
float CPlayerCalcDPRate62_wrapper(struct CPlayer* _this);
void CPlayerCalcDefTol64_wrapper(struct CPlayer* _this);
int CPlayerCalcEquipAttackDelay66_wrapper(struct CPlayer* _this);
void CPlayerCalcEquipMaxDP68_wrapper(struct CPlayer* _this, bool bInit);
void CPlayerCalcEquipSpeed70_wrapper(struct CPlayer* _this);
void CPlayerCalcExp72_wrapper(struct CPlayer* _this, struct CCharacter* pDst, int nDam, struct CPartyModeKillMonsterExpNotify* kPartyExpNotify);
void CPlayerCalcPvP74_wrapper(struct CPlayer* _this, struct CPlayer* pDier, char byKillerObjID);
void CPlayerCheckAlterMaxPoint76_wrapper(struct CPlayer* _this);
void CPlayerCheckBattleMode78_wrapper(struct CPlayer* _this);
void CPlayerCheckGroupMapPoint80_wrapper(struct CPlayer* _this);
void CPlayerCheckGroupTargeting82_wrapper(struct CPlayer* _this);
void CPlayerCheckMentalTakeAndUpdateLastMetalTicket84_wrapper(struct CPlayer* _this, char* strItemCode);
void CPlayerCheckNameChange86_wrapper(struct CPlayer* _this);
void CPlayerCheckPosInTown88_wrapper(struct CPlayer* _this);
void CPlayerCheckPos_Region90_wrapper(struct CPlayer* _this);
void CPlayerCheckUnitCutTime92_wrapper(struct CPlayer* _this);
void CPlayerCheet_BufEffectEnd94_wrapper(struct CPlayer* _this);
void CPlayerClearGravityStone96_wrapper(struct CPlayer* _this);
bool CPlayerCorpse98_wrapper(struct CPlayer* _this, struct CCharacter* pAtter);
bool CPlayerCreate100_wrapper(struct CPlayer* _this);
void CPlayerCreateComplete102_wrapper(struct CPlayer* _this);
void CPlayerDTradeInit104_wrapper(struct CPlayer* _this);
bool CPlayerDecHalfSFContDam106_wrapper(struct CPlayer* _this, float fEffVal);
void CPlayerDelPostData108_wrapper(struct CPlayer* _this, unsigned int dwIndex);
void CPlayerDeleteCouponItem110_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* CouponItem, int n);
bool CPlayerDeleteUseConsumeItem112_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con** ppConsumeItems, int* pnConsume, bool* pbOverLap);
struct _STORAGE_LIST::_db_con* CPlayerEmb_AddStorage114_wrapper(struct CPlayer* _this, char byStorageCode, struct _STORAGE_LIST::_storage_con* pCon, bool bEquipChange, bool bAdd);
unsigned int CPlayerEmb_AlterDurPoint116_wrapper(struct CPlayer* _this, char byStorageCode, char byStorageIndex, int nAlter, bool bUpdate, bool bSend);
void CPlayerEmb_AlterStat118_wrapper(struct CPlayer* _this, char byMasteryClass, char byIndex, unsigned int dwAlter, char byReason, char* strErrorCodePos, bool bPcbangPrimiumFavorReward);
void CPlayerEmb_AlterStat_F120_wrapper(struct CPlayer* _this, char byMasteryClass, char byIndex, float fAlter, char byReason);
bool CPlayerEmb_CheckActForQuest122_wrapper(struct CPlayer* _this, int nActCode, char* pszReqCode, uint16_t wAddCount, bool bParty);
void CPlayerEmb_CheckActForQuestParty124_wrapper(struct CPlayer* _this, int nActCode, char* pszReqCode, uint16_t wAddCount);
void CPlayerEmb_CompleteQuest126_wrapper(struct CPlayer* _this, char byQuestDBSlot, char byRewardItemIndex, char byLinkQuestIndex);
bool CPlayerEmb_CreateNPCQuest128_wrapper(struct CPlayer* _this, char* pszEventCode, unsigned int dwNPCQuestIndex);
bool CPlayerEmb_CreateQuestEvent130_wrapper(struct CPlayer* _this, QUEST_HAPPEN HappenType, char* pszEventCode);
bool CPlayerEmb_DelStorage132_wrapper(struct CPlayer* _this, char byStorageCode, char byStorageIndex, bool bEquipChange, bool bDelete, char* strErrorCodePos);
void CPlayerEmb_EquipLink134_wrapper(struct CPlayer* _this);
void CPlayerEmb_ItemUpgrade136_wrapper(struct CPlayer* _this, char byUpgradeType, char byStorageCode, char byStorageIndex, unsigned int dwGradeInfo);
void CPlayerEmb_RidindUnit138_wrapper(struct CPlayer* _this, bool bRiding, struct CParkingUnit* pCreateUnit);
bool CPlayerEmb_StartQuest140_wrapper(struct CPlayer* _this, char bySelectQuest, struct _happen_event_cont* pHappenEvent);
int CPlayerEmb_UpdateStat142_wrapper(struct CPlayer* _this, unsigned int dwStatIndex, unsigned int dwNewData, unsigned int dwOldData);
void CPlayerExitUpdateDataToWorld144_wrapper(struct CPlayer* _this);
void CPlayerExtractStringToTime146_wrapper(struct CPlayer* _this, unsigned int dwTemp, struct _SYSTEMTIME* tm);
struct CPlayer* CPlayerFindFarChatPlayerWithTemp148_wrapper(struct CPlayer* _this, char* pwszName);
bool CPlayerFixTargetWhile150_wrapper(struct CPlayer* _this, struct CCharacter* pkTarget, unsigned int dwMiliSecond);
void CPlayerForcePullUnit152_wrapper(struct CPlayer* _this, bool bLogout);
float CPlayerGetAddSpeed154_wrapper(struct CPlayer* _this);
struct _sf_continous* CPlayerGetAfterEffect156_wrapper(struct CPlayer* _this);
int CPlayerGetAttackDP158_wrapper(struct CPlayer* _this);
int CPlayerGetAttackLevel160_wrapper(struct CPlayer* _this);
float CPlayerGetAttackRange162_wrapper(struct CPlayer* _this);
int CPlayerGetAvoidRate164_wrapper(struct CPlayer* _this);
int CPlayerGetBillingType166_wrapper(struct CPlayer* _this);
struct _dummy_position* CPlayerGetBindDummy168_wrapper(struct CPlayer* _this);
struct CMapData* CPlayerGetBindMap170_wrapper(struct CPlayer* _this, float* pfPos, bool bIgnoreMapClass);
struct CMapData* CPlayerGetBindMapData172_wrapper(struct CPlayer* _this);
int CPlayerGetCashAmount174_wrapper(struct CPlayer* _this);
int CPlayerGetDP176_wrapper(struct CPlayer* _this);
int CPlayerGetDamageDP178_wrapper(struct CPlayer* _this, int nAttackPart);
int CPlayerGetDamageLevel180_wrapper(struct CPlayer* _this, int nAttackPart);
int CPlayerGetDefFC182_wrapper(struct CPlayer* _this, int nAttactPart, struct CCharacter* pAttChar, int* pnConvertPart);
float CPlayerGetDefFacing184_wrapper(struct CPlayer* _this, int nPart);
float CPlayerGetDefGap186_wrapper(struct CPlayer* _this, int nPart);
int CPlayerGetDefSkill188_wrapper(struct CPlayer* _this, bool bBackAttackDamage);
char CPlayerGetEffectEquipCode190_wrapper(struct CPlayer* _this, char byStorageCode, char bySlotIndex);
int CPlayerGetFP192_wrapper(struct CPlayer* _this);
int CPlayerGetFireTol194_wrapper(struct CPlayer* _this);
int CPlayerGetGauge196_wrapper(struct CPlayer* _this, int nParamCode);
int CPlayerGetGenAttackProb198_wrapper(struct CPlayer* _this, struct CCharacter* pDst, int nPart, bool bBackAttack);
struct CPlayer::__target* CPlayerGetGroupTarget200_wrapper(struct CPlayer* _this, char byGroupType);
int CPlayerGetHP202_wrapper(struct CPlayer* _this);
unsigned int CPlayerGetInitClassCost204_wrapper(struct CPlayer* _this);
int CPlayerGetLevel206_wrapper(struct CPlayer* _this);
int CPlayerGetMasteryCumAfterAttack208_wrapper(struct CPlayer* _this, int nDstLv);
int CPlayerGetMaxDP210_wrapper(struct CPlayer* _this);
int CPlayerGetMaxFP212_wrapper(struct CPlayer* _this);
int CPlayerGetMaxHP214_wrapper(struct CPlayer* _this);
int CPlayerGetMaxSP216_wrapper(struct CPlayer* _this);
unsigned int CPlayerGetMoney218_wrapper(struct CPlayer* _this, char byMoneyCode);
float CPlayerGetMoveSpeed220_wrapper(struct CPlayer* _this);
char* CPlayerGetObjName222_wrapper(struct CPlayer* _this);
int CPlayerGetObjRace224_wrapper(struct CPlayer* _this);
float CPlayerGetPartyExpDistributionRate226_wrapper(struct CPlayer* _this, int iPartyMemberLevel, int iMaxLevel, int i2ndLevel);
struct CPvpOrderView* CPlayerGetPvpOrderView228_wrapper(struct CPlayer* _this);
long double CPlayerGetPvpPointLeak230_wrapper(struct CPlayer* _this);
struct CPvpPointLimiter* CPlayerGetPvpPointLimiter232_wrapper(struct CPlayer* _this, struct CPvpPointLimiter* result);
struct CAnimus* CPlayerGetRecallAnimus234_wrapper(struct CPlayer* _this);
int CPlayerGetRewardItems_DarkDungeon236_wrapper(struct CPlayer* _this, struct _dh_reward_sub_setup* pSetup, struct _STORAGE_LIST::_db_con* pItems, int bRealBoss);
int CPlayerGetSP238_wrapper(struct CPlayer* _this);
int CPlayerGetSoilTol240_wrapper(struct CPlayer* _this);
uint64_t CPlayerGetStateFlag242_wrapper(struct CPlayer* _this);
struct CGameObject* CPlayerGetTargetObj244_wrapper(struct CPlayer* _this);
bool CPlayerGetUseConsumeItem246_wrapper(struct CPlayer* _this, struct _consume_item_list* pConsumeList, uint16_t* pItemSerials, struct _STORAGE_LIST::_db_con** ppConsumeItems, int* pnConsume, bool* pbOverLap);
int CPlayerGetVisualVer248_wrapper(struct CPlayer* _this);
int CPlayerGetWaterTol250_wrapper(struct CPlayer* _this);
float CPlayerGetWeaponAdjust252_wrapper(struct CPlayer* _this);
int CPlayerGetWeaponClass254_wrapper(struct CPlayer* _this);
int CPlayerGetWeaponRange256_wrapper(struct CPlayer* _this);
float CPlayerGetWidth258_wrapper(struct CPlayer* _this);
int CPlayerGetWindTol260_wrapper(struct CPlayer* _this);
void CPlayerGuild_Buy_Emblem_Complete262_wrapper(struct _DB_QRY_SYN_DATA* pData);
void CPlayerGuild_Disjoint_Complete264_wrapper(struct _DB_QRY_SYN_DATA* pData);
void CPlayerGuild_Force_Leave_Complete266_wrapper(struct _DB_QRY_SYN_DATA* pData);
void CPlayerGuild_Insert_Complete268_wrapper(struct _DB_QRY_SYN_DATA* pData);
void CPlayerGuild_Join_Accept_Complete270_wrapper(struct _DB_QRY_SYN_DATA* pData);
void CPlayerGuild_Pop_Money_Complete272_wrapper(struct _DB_QRY_SYN_DATA* pData);
void CPlayerGuild_Push_Money_Complete274_wrapper(struct _DB_QRY_SYN_DATA* pData);
void CPlayerGuild_Self_Leave_Complete276_wrapper(struct _DB_QRY_SYN_DATA* pData);
void CPlayerGuild_Update_GuildMater_Complete278_wrapper(struct _DB_QRY_SYN_DATA* pData);
void CPlayerHSKQuestEnd_Att280_wrapper(struct CPlayer* _this, char byDestroyStoneRaceCode, struct CPlayer* pDestroyer);
void CPlayerHideNameEffect282_wrapper(struct CPlayer* _this, bool bAdd);
void CPlayerIncCriEffKillPoint284_wrapper(struct CPlayer* _this);
void CPlayerIncCriEffPvPCashBag286_wrapper(struct CPlayer* _this, long double dAlter);
void CPlayerIncPvPPoint288_wrapper(struct CPlayer* _this, long double dAlter, PVP_ALTER_TYPE AlterType, unsigned int dwDstSerial);
bool CPlayerInit290_wrapper(struct CPlayer* _this, struct _object_id* pID);
bool CPlayerIntoMap292_wrapper(struct CPlayer* _this, char byMapInMode);
bool CPlayerIsActingSiegeMode294_wrapper(struct CPlayer* _this);
bool CPlayerIsApplyPcbangPrimium296_wrapper(struct CPlayer* _this);
bool CPlayerIsBeAttackedAble298_wrapper(struct CPlayer* _this, bool bFirst);
bool CPlayerIsBeDamagedAble300_wrapper(struct CPlayer* _this, struct CCharacter* pAtter);
struct _STORAGE_LIST::_db_con* CPlayerIsBulletValidity302_wrapper(struct CPlayer* _this, uint16_t wBulletSerial);
bool CPlayerIsChaosMode304_wrapper(struct CPlayer* _this);
struct _STORAGE_LIST::_db_con* CPlayerIsEffBulletValidity306_wrapper(struct CPlayer* _this, uint16_t wEffBulletSerial);
bool CPlayerIsEffectableEquip308_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_storage_con* pCon);
bool CPlayerIsEquipAbleGrade310_wrapper(struct CPlayer* _this, char byGradeLv);
bool CPlayerIsHaveMentalTicket312_wrapper(struct CPlayer* _this);
bool CPlayerIsInTown314_wrapper(struct CPlayer* _this);
bool CPlayerIsLastAttBuff316_wrapper(struct CPlayer* _this);
bool CPlayerIsMapLoading318_wrapper(struct CPlayer* _this);
bool CPlayerIsMineMode320_wrapper(struct CPlayer* _this);
bool CPlayerIsMiningByMinigTicket322_wrapper(struct CPlayer* _this);
bool CPlayerIsOutExtraStopPos324_wrapper(struct CPlayer* _this, float* pfStopPos);
bool CPlayerIsOverOneDay326_wrapper(struct CPlayer* _this);
bool CPlayerIsPassExpLimitLvDiff328_wrapper(struct CPlayer* _this, int iDstLevel, bool* bGetAttackExp);
bool CPlayerIsPassMasteryLimitLvDiff330_wrapper(struct CPlayer* _this, int iDstLevel);
bool CPlayerIsPunished332_wrapper(struct CPlayer* _this, char byType, bool bSend);
bool CPlayerIsRecallAnimus334_wrapper(struct CPlayer* _this);
bool CPlayerIsRecvableContEffect336_wrapper(struct CPlayer* _this);
bool CPlayerIsReturnPostUpdate338_wrapper(struct CPlayer* _this);
bool CPlayerIsRidingShip340_wrapper(struct CPlayer* _this);
bool CPlayerIsRidingUnit342_wrapper(struct CPlayer* _this);
bool CPlayerIsSFActableByClass344_wrapper(struct CPlayer* _this, char byEffectCode, struct _base_fld* pSFFld);
bool CPlayerIsSFUsableGauge346_wrapper(struct CPlayer* _this, char byEffectCode, uint16_t wEffectIndex, uint16_t* pwDelPoint);
bool CPlayerIsSFUsableSFMastery348_wrapper(struct CPlayer* _this, char byMasteryCode, int nMasteryIndex);
bool CPlayerIsSFUseableRace350_wrapper(struct CPlayer* _this, char byEffectCode, uint16_t wEffectIndex);
bool CPlayerIsSiegeMode352_wrapper(struct CPlayer* _this);
bool CPlayerIsTargetObj354_wrapper(struct CPlayer* _this, struct CGameObject* pkObj);
bool CPlayerIsUsableAccountType356_wrapper(struct CPlayer* _this, int nCashType);
bool CPlayerIsUseCloakBooster358_wrapper(struct CPlayer* _this);
bool CPlayerIsUseReleaseRaceBuffPotion360_wrapper(struct CPlayer* _this);
bool CPlayerIs_Battle_Mode362_wrapper(struct CPlayer* _this);
void CPlayerLimLvNpcQuestDelete364_wrapper(struct CPlayer* _this, char byQuestDBSlot);
bool CPlayerLoad366_wrapper(struct CPlayer* _this, struct CUserDB* pUser, bool bFirstStart);
void CPlayerLoop368_wrapper(struct CPlayer* _this);
void CPlayerNetClose370_wrapper(struct CPlayer* _this, bool bMoveOutLobby);
void CPlayerNewViewCircleObject372_wrapper(struct CPlayer* _this);
void CPlayerOnLoop_Static374_wrapper();
bool CPlayerOutOfMap376_wrapper(struct CPlayer* _this, struct CMapData* pIntoMap, uint16_t wLayerIndex, char byMapOutType, float* pfStartPos);
void CPlayerOutOfSec378_wrapper(struct CPlayer* _this);
void CPlayerPastWhisperInit380_wrapper(struct CPlayer* _this);
void CPlayerPotion_Buf_Extend382_wrapper(struct CPlayer* _this);
void CPlayerPushDQSCheatPlyerVoteInfo384_wrapper(struct CPlayer* _this);
void CPlayerPushDQSUpdatePlyerVoteInfo386_wrapper(struct CPlayer* _this);
void CPlayerPushDQSUpdateVoteAvilable388_wrapper(struct CPlayer* _this);
void CPlayerReCalcMaxHFSP390_wrapper(struct CPlayer* _this, bool bSend, bool bRatio);
void CPlayerRecallRandomPositionInRange392_wrapper(struct CPlayer* _this, struct CMapData* pIntoMap, uint16_t wMapLayerIndex, float* pStartPos, int iRange);
void CPlayerRecvHSKQuest394_wrapper(struct CPlayer* _this, char byHSKQuestCode, char byCristalBattleDBInfo, int nPvpPoint, uint16_t wKillPoint, uint16_t wDieCount, char byHSKTime);
void CPlayerRecvKillMessage396_wrapper(struct CPlayer* _this, struct CCharacter* pDier);
void CPlayerReservationForceClose398_wrapper(struct CPlayer* _this);
void CPlayerResurrect400_wrapper(struct CPlayer* _this);
void CPlayerReturn_AnimusAsk402_wrapper(struct CPlayer* _this, char byReturnType);
void CPlayerRewardChangeClass404_wrapper(struct CPlayer* _this, struct _class_fld* pClassFld, char bySelectRewardItem);
void CPlayerRewardChangeClassMastery406_wrapper(struct CPlayer* _this, struct _class_fld* pClassFld);
void CPlayerRewardChangeClassRewardItem408_wrapper(struct CPlayer* _this, struct _class_fld* pClassFld, char bySelectRewardItem);
void CPlayerRewardRaceWarPvpCash410_wrapper(struct CPlayer* _this);
void CPlayerReward_DarkDungeon412_wrapper(struct CPlayer* _this, struct _dh_reward_sub_setup* pSetup, char* pszTitle, int bRealBoss, struct _STORAGE_LIST::_db_con* pItem, int* bIsRewarded);
bool CPlayerRobbedHP414_wrapper(struct CPlayer* _this, struct CCharacter* pDst, int nDecHP);
void CPlayerSFContDelMessage416_wrapper(struct CPlayer* _this, char byContCode, char byListIndex, bool bSend, bool bAura);
void CPlayerSFContInsertMessage418_wrapper(struct CPlayer* _this, char byContCode, char byListIndex, bool bAuraSkill, struct CPlayer* pPlayerAct);
void CPlayerSFContUpdateTimeMessage420_wrapper(struct CPlayer* _this, char byContCode, char byListIndex, int nLeftTime);
bool CPlayerSF_AllContDamageForceRemove_Once422_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj);
bool CPlayerSF_AllContDamageRemove_Once424_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj);
bool CPlayerSF_AllContHelpForceRemove_Once426_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj);
bool CPlayerSF_AllContHelpSkillRemove_Once428_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj);
bool CPlayerSF_AttHPtoDstFP_Once430_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_ContDamageTimeInc_Once432_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_ContHelpTimeInc_Once434_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_ConvertMonsterTarget436_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_ConvertTargetDest438_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_DamageAndStun440_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_FPDec442_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_HFSInc_Once444_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj);
bool CPlayerSF_HPInc_Once446_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_IncHPCircleParty448_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_IncreaseDP450_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_LateContDamageRemove_Once452_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj);
bool CPlayerSF_LateContHelpForceRemove_Once454_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj);
bool CPlayerSF_LateContHelpSkillRemove_Once456_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj);
bool CPlayerSF_MakePortalReturnBindPositionPartyMember458_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue, char* byRet);
bool CPlayerSF_MakeZeroAnimusRecallTimeOnce460_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_OthersContHelpSFRemove_Once462_wrapper(struct CPlayer* _this, float fEffectValue);
bool CPlayerSF_OverHealing_Once464_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_RecoverAllReturnStateAnimusHPFull466_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_ReleaseMonsterTarget468_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_RemoveAllContHelp_Once470_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_Resurrect_Once472_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj);
bool CPlayerSF_ReturnBindPosition474_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_SPDec476_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_STInc_Once478_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_SelfDestruction480_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_SkillContHelpTimeInc_Once482_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_Stun484_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
bool CPlayerSF_TeleportToDestination486_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, bool bStone);
bool CPlayerSF_TransDestHP488_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue, char* byRet);
bool CPlayerSF_TransMonsterHP490_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue);
void CPlayerSendData_ChatTrans492_wrapper(struct CPlayer* _this, char byChatType, unsigned int dwSenderSerial, char byRaceCode, bool bFilter, char* pwszMessage, char byPvpGrade, char* pwszSender);
void CPlayerSendData_PartyMemberEffect494_wrapper(struct CPlayer* _this, char byAlterCode, uint16_t wEffectCode, char byLv);
void CPlayerSendData_PartyMemberFP496_wrapper(struct CPlayer* _this);
void CPlayerSendData_PartyMemberHP498_wrapper(struct CPlayer* _this);
void CPlayerSendData_PartyMemberInfo500_wrapper(struct CPlayer* _this, uint16_t wDstIndex);
void CPlayerSendData_PartyMemberInfoToMembers502_wrapper(struct CPlayer* _this);
void CPlayerSendData_PartyMemberLv504_wrapper(struct CPlayer* _this);
void CPlayerSendData_PartyMemberMaxHFSP506_wrapper(struct CPlayer* _this);
void CPlayerSendData_PartyMemberPos508_wrapper(struct CPlayer* _this);
void CPlayerSendData_PartyMemberSP510_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AMPInvenDownloadResult512_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AddBagResult514_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_AddEffect516_wrapper(struct CPlayer* _this, uint16_t wEffectCode, char byLv, uint16_t wDurSec, unsigned int dwPlayerSerial, char* wszPlayerName);
void CPlayerSendMsg_AdjustAmountInform518_wrapper(struct CPlayer* _this, char byStorageCode, uint16_t wSerial, unsigned int dwDur);
void CPlayerSendMsg_AlterBooster520_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterContEffectTime522_wrapper(struct CPlayer* _this, char byContType);
void CPlayerSendMsg_AlterEquipSPInform524_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterExpInform526_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterGradeInform528_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterHPInform530_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterItemDurInform532_wrapper(struct CPlayer* _this, char byStorageCode, uint16_t wItemSerial, uint64_t dwDur);
void CPlayerSendMsg_AlterMaxDP534_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterMoneyInform536_wrapper(struct CPlayer* _this, char byReasonCode);
void CPlayerSendMsg_AlterPvPCash538_wrapper(struct CPlayer* _this, int nIOCode);
void CPlayerSendMsg_AlterPvPPoint540_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterPvPRank542_wrapper(struct CPlayer* _this, uint16_t wPvpRate, unsigned int dwPvpRank);
void CPlayerSendMsg_AlterRegionInform544_wrapper(struct CPlayer* _this, int nRegionIndex);
void CPlayerSendMsg_AlterSPInform546_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterTol548_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterTowerHP550_wrapper(struct CPlayer* _this, uint16_t wItemSerial, uint16_t wLeftHP);
void CPlayerSendMsg_AlterTownOrField552_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AlterUnitBulletInform554_wrapper(struct CPlayer* _this, char byPart, uint16_t wLeftNum);
void CPlayerSendMsg_AlterUnitHPInform556_wrapper(struct CPlayer* _this, char bySlotIndex, unsigned int dwGauge);
void CPlayerSendMsg_AlterWeaponBulletInform558_wrapper(struct CPlayer* _this, uint16_t wItemSerial, uint16_t wLeftNum);
void CPlayerSendMsg_Alter_Action_Point560_wrapper(struct CPlayer* _this, char byActCode, unsigned int dwActPoint);
void CPlayerSendMsg_AnimusExpInform562_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AnimusFPInform564_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AnimusHPInform566_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_AnimusInvenChange568_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_AnimusModeInform570_wrapper(struct CPlayer* _this, char byMode);
void CPlayerSendMsg_AnimusRecallResult572_wrapper(struct CPlayer* _this, char byResultCode, uint16_t wLeftFP, struct CAnimus* pNewAnimus);
void CPlayerSendMsg_AnimusRecallWaitTimeFree574_wrapper(struct CPlayer* _this, bool bFree);
void CPlayerSendMsg_AnimusReturnResult576_wrapper(struct CPlayer* _this, char byRetCode, uint16_t wAnimusItemSerial, char byReturnType);
void CPlayerSendMsg_AnimusTargetResult578_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_ApexInform580_wrapper(struct CPlayer* _this, unsigned int dwRecvSize, char* pMsg);
void CPlayerSendMsg_AttackResult_Count582_wrapper(struct CPlayer* _this, struct CAttack* pAt);
void CPlayerSendMsg_AttackResult_Error584_wrapper(struct CPlayer* _this, int nErrCode);
void CPlayerSendMsg_AttackResult_Force586_wrapper(struct CPlayer* _this, struct CAttack* pAt);
void CPlayerSendMsg_AttackResult_Gen588_wrapper(struct CPlayer* _this, struct CAttack* pAt, uint16_t wBulletIndex);
void CPlayerSendMsg_AttackResult_SelfDestruction590_wrapper(struct CPlayer* _this, struct CAttack* pAt);
void CPlayerSendMsg_AttackResult_Siege592_wrapper(struct CPlayer* _this, struct CAttack* pAt, uint16_t wBulletIndex);
void CPlayerSendMsg_AttackResult_Skill594_wrapper(struct CPlayer* _this, char byEffectCode, struct CPlayerAttack* pAt, uint16_t wBulletIndex);
void CPlayerSendMsg_AttackResult_Unit596_wrapper(struct CPlayer* _this, struct CAttack* pAt, char byWeaponPart, uint16_t wBulletIndex);
void CPlayerSendMsg_AwayPartyInvitationQuestion598_wrapper(struct CPlayer* _this, uint16_t wJoinerIndex);
void CPlayerSendMsg_AwayPartyRequestResult600_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_BackTowerResult602_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wItemSerial, uint16_t wLeftHP);
void CPlayerSendMsg_BackTrapResult604_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_BaseDownloadResult606_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_BillingExipreInform608_wrapper(struct CPlayer* _this, char byKind, uint16_t wWaitSec);
void CPlayerSendMsg_BillingTypeChangeInform610_wrapper(struct CPlayer* _this, int16_t iType, int lRemainTime, struct _SYSTEMTIME* pstEndDate, char byReason);
void CPlayerSendMsg_BreakdownEquipItem612_wrapper(struct CPlayer* _this, char byPartIndex, uint16_t wSerial);
void CPlayerSendMsg_BuddhaEventMsg614_wrapper(struct CPlayer* _this, char byErrorCode);
void CPlayerSendMsg_BuddyAddAnswerResult616_wrapper(struct CPlayer* _this, char byRetCode, bool bAccept, unsigned int dwAskerSerial, uint16_t wIndex, unsigned int dwSerial, char* pwszCharName);
void CPlayerSendMsg_BuddyAddAsk618_wrapper(struct CPlayer* _this, uint16_t wAskerIndex, unsigned int dwAskerSerial, char* pwszAskerName);
void CPlayerSendMsg_BuddyAddFail620_wrapper(struct CPlayer* _this, char byRetCode, char* pwszDstName);
void CPlayerSendMsg_BuddyDelResult622_wrapper(struct CPlayer* _this, char byRetCode, unsigned int dwSerial);
void CPlayerSendMsg_BuddyLoginInform624_wrapper(struct CPlayer* _this, unsigned int dwObjSerial, char byMapIndex, char byPosCode);
void CPlayerSendMsg_BuddyLogoffInform626_wrapper(struct CPlayer* _this, unsigned int dwObjSerial);
void CPlayerSendMsg_BuddyNameReNewal628_wrapper(struct CPlayer* _this, unsigned int dwSerial, char* wszName);
void CPlayerSendMsg_BuddyPosInform630_wrapper(struct CPlayer* _this, unsigned int dwDstSerial, char byMapIndex, char byPosCode);
void CPlayerSendMsg_BuyCashItemMode632_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_BuyItemStoreResult634_wrapper(struct CPlayer* _this, struct CItemStore* pStore, int nOfferNum, struct _buy_offer* pCard, char byErrCode);
void CPlayerSendMsg_CancelSuggestResult636_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_CastVoteResult638_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_ChangeClassCommand640_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_CharacterRenameCashResult642_wrapper(struct CPlayer* _this, bool bChange, char byErrCode);
void CPlayerSendMsg_ChatFarFailure644_wrapper(struct CPlayer* _this, bool bBlock);
void CPlayerSendMsg_Circle_DelEffect646_wrapper(struct CPlayer* _this, char byEffectCode, uint16_t wEffectIndex, char byLv, bool bToOne);
void CPlayerSendMsg_ClassSkillResult648_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, uint16_t wSkillIndex);
void CPlayerSendMsg_ClearDarkHole650_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_CombineItemExAcceptResult652_wrapper(struct CPlayer* _this, struct _combine_ex_item_accept_result_zocl* pSend);
void CPlayerSendMsg_CombineItemExResult654_wrapper(struct CPlayer* _this, struct _combine_ex_item_result_zocl* pSend);
void CPlayerSendMsg_CombineItemResult656_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwFee, struct _STORAGE_LIST::_db_con* pNewItem);
void CPlayerSendMsg_CombineLendItemResult658_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwFee, struct _STORAGE_LIST::_db_con* pNewItem);
void CPlayerSendMsg_CreateTowerResult660_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwTowerObjSerial);
void CPlayerSendMsg_CreateTrapResult662_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwTrapObjSerial);
void CPlayerSendMsg_CumDownloadResult664_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_CuttingCompleteResult666_wrapper(struct CPlayer* _this, char byRet);
void CPlayerSendMsg_DTradeAccomplishInform668_wrapper(struct CPlayer* _this, bool bSucc, uint16_t wStartSerial);
void CPlayerSendMsg_DTradeAddInform670_wrapper(struct CPlayer* _this, char bySlotIndex, struct _STORAGE_LIST::_db_con* pItem, char byAmount);
void CPlayerSendMsg_DTradeAddResult672_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_DTradeAnswerResult674_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_DTradeAskInform676_wrapper(struct CPlayer* _this, struct CPlayer* pAsker);
void CPlayerSendMsg_DTradeAskResult678_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_DTradeBetInform680_wrapper(struct CPlayer* _this, char byUnitCode, unsigned int dwAmount);
void CPlayerSendMsg_DTradeBetResult682_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_DTradeCancleInform684_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_DTradeCancleResult686_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_DTradeCloseInform688_wrapper(struct CPlayer* _this, char byCloseCode);
void CPlayerSendMsg_DTradeDelInform690_wrapper(struct CPlayer* _this, char bySlotIndex);
void CPlayerSendMsg_DTradeDelResult692_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_DTradeLockInform694_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_DTradeLockResult696_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_DTradeOKInform698_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_DTradeOKResult700_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_DTradeStartInform702_wrapper(struct CPlayer* _this, struct CPlayer* pAsker, struct CPlayer* pAnswer, unsigned int* pdwKey);
void CPlayerSendMsg_DTradeUnitAddInform704_wrapper(struct CPlayer* _this, uint16_t wUnitKeySerial, struct _UNIT_DB_BASE::_LIST* pUnitData);
void CPlayerSendMsg_DTradeUnitInfoInform706_wrapper(struct CPlayer* _this, char byTradeSlotIndex, struct _UNIT_DB_BASE::_LIST* pUnitData);
void CPlayerSendMsg_DamageResult708_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem);
void CPlayerSendMsg_DarkHoleOpenFail710_wrapper(struct CPlayer* _this, int n, char byErrCode);
void CPlayerSendMsg_DarkHoleOpenResult712_wrapper(struct CPlayer* _this, int n, int bPartyOnly, char byErrCode, uint16_t wHoleIndex, unsigned int dwHoleSerial);
void CPlayerSendMsg_DarkHoleRewardMessage714_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, unsigned int dwMemberIndex, int isRewarded);
void CPlayerSendMsg_DelEffect716_wrapper(struct CPlayer* _this, char byEffectCode, uint16_t wEffectIndex, char byLv);
void CPlayerSendMsg_DeleteStorageInform718_wrapper(struct CPlayer* _this, char byStorageCode, uint16_t wSerial);
void CPlayerSendMsg_Destroy720_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_Die722_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_EconomyHistoryInform724_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_EconomyRateInform726_wrapper(struct CPlayer* _this, bool bStart);
void CPlayerSendMsg_EmbellishResult728_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_EnterDarkHole730_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwHoleSerial);
void CPlayerSendMsg_EquipItemLevelLimit732_wrapper(struct CPlayer* _this, int nCurPlayerLv);
void CPlayerSendMsg_EquipPartChange734_wrapper(struct CPlayer* _this, char byPart);
void CPlayerSendMsg_EquipPartResult736_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_ExchangeItemResult738_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pNewItem);
void CPlayerSendMsg_ExchangeLendItemResult740_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pNewItem);
void CPlayerSendMsg_ExchangeMoneyResult742_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_ExitWorldResult744_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_ExtTrunkExtendResult746_wrapper(struct CPlayer* _this, char byRetCode, char bySlotNum, char byLackSlotNum);
void CPlayerSendMsg_FanfareItem748_wrapper(struct CPlayer* _this, char byGetType, struct _STORAGE_LIST::_db_con* pItem, struct CItemBox* pItemBox);
void CPlayerSendMsg_FcitemInform750_wrapper(struct CPlayer* _this, uint16_t wItemSerial, unsigned int dwNewStat);
void CPlayerSendMsg_FixPosition752_wrapper(struct CPlayer* _this, int n);
void CPlayerSendMsg_ForceDownloadResult754_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_ForceInvenChange756_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_ForceResult758_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, struct _STORAGE_LIST::_db_con* pForceItem, int nSFLv);
void CPlayerSendMsg_GM_Greeting760_wrapper(struct CPlayer* _this, char* wszGMName, char* wszMsg);
void CPlayerSendMsg_GUILD_Greeting762_wrapper(struct CPlayer* _this, char* wszName, char* wszMsg);
void CPlayerSendMsg_GestureInform764_wrapper(struct CPlayer* _this, char byGestureType);
void CPlayerSendMsg_GiveupDarkHole766_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_GotoBasePortalResult768_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_GotoRecallResult770_wrapper(struct CPlayer* _this, char byErrCode, char byMapCode, float* pfStartPos, char byMapInType);
void CPlayerSendMsg_GroupTargetInform772_wrapper(struct CPlayer* _this, char byGroupType, char* pwszName);
void CPlayerSendMsg_GuildEstablishFail774_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_GuildForceLeaveBoradori776_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_GuildJoinAcceptFail778_wrapper(struct CPlayer* _this, char byRetCode, unsigned int dwApplierSerial);
void CPlayerSendMsg_GuildJoinApplyCancelResult780_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_GuildJoinApplyRejectInform782_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_GuildJoinApplyResult784_wrapper(struct CPlayer* _this, char byRetCode, struct CGuild* pApplyGuild);
void CPlayerSendMsg_GuildJoinOtherInform786_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_GuildManageResult788_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_GuildMasterEffect790_wrapper(struct CPlayer* _this, char byState, char byGrade, char byEffSubAttack, char byEffSubDefence, char byEffAddAttack, char byEffAddDefence);
void CPlayerSendMsg_GuildPushMoneyResult792_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_GuildRoomEnterResult794_wrapper(struct CPlayer* _this, char byRetCode, char bySubRetCode, char byMapIndex, uint16_t wMapLayer, float* pPos, int tt);
void CPlayerSendMsg_GuildRoomOutResult796_wrapper(struct CPlayer* _this, char byRetCode, char byMapIndex, uint16_t wMapLayer, float* pPos);
void CPlayerSendMsg_GuildRoomRentResult798_wrapper(struct CPlayer* _this, char byRetCode, char bySubRetCode, char byRoomType);
void CPlayerSendMsg_GuildRoomRestTimeResult800_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_GuildSelfLeaveResult802_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_GuildSetHonorResult804_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_HSKQuestActCum806_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_HSKQuestSucc808_wrapper(struct CPlayer* _this, char byQuestCode, bool bSucc);
void CPlayerSendMsg_HonorGuildMark810_wrapper(struct CPlayer* _this, char byRank);
void CPlayerSendMsg_InformTaxIncome812_wrapper(struct CPlayer* _this, char byRet, unsigned int dwComm, char* pwszDate);
void CPlayerSendMsg_Init_Action_Point814_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_InsertItemInform816_wrapper(struct CPlayer* _this, char byStorageCode, struct _STORAGE_LIST::_db_con* pItem);
void CPlayerSendMsg_InsertNewQuest818_wrapper(struct CPlayer* _this, char bySlotIndex, struct _QUEST_DB_BASE::_LIST* pQuestDB);
void CPlayerSendMsg_InsertNextQuest820_wrapper(struct CPlayer* _this, char bySlotIndex, struct _QUEST_DB_BASE::_LIST* pQuestDB);
void CPlayerSendMsg_InsertQuestFailure822_wrapper(struct CPlayer* _this, char byEventType, unsigned int dwEventIndex, char byEventNodeIndex);
void CPlayerSendMsg_InsertQuestItemInform824_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem);
void CPlayerSendMsg_InvenDownloadResult826_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_ItemDowngrade828_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_ItemStorageRefresh830_wrapper(struct CPlayer* _this, char byStorageCode);
void CPlayerSendMsg_ItemUpgrade832_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_JadeEffectErr834_wrapper(struct CPlayer* _this, char byErrorCode);
void CPlayerSendMsg_LendItemTimeExpired836_wrapper(struct CPlayer* _this, char byStorageCode, uint16_t wSerial);
void CPlayerSendMsg_Level838_wrapper(struct CPlayer* _this, int nLevel);
void CPlayerSendMsg_LinkBoardDownloadResult840_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_MacroRequest842_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_MadeTrapNumInform844_wrapper(struct CPlayer* _this, char byNum);
void CPlayerSendMsg_MakeItemCheatSendButtonEnable846_wrapper(struct CPlayer* _this, bool bEnableSendButton);
void CPlayerSendMsg_MakeItemResult848_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_MapEnvInform850_wrapper(struct CPlayer* _this, char byMapCode, unsigned int dwMapEnvCode);
void CPlayerSendMsg_MapOut852_wrapper(struct CPlayer* _this, char byMapOutCode, char byNextMapCode);
void CPlayerSendMsg_MaxHFSP854_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_MaxPvpPointInform856_wrapper(struct CPlayer* _this, int nMax);
void CPlayerSendMsg_MineCancle858_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_MineCompleteResult860_wrapper(struct CPlayer* _this, char byErrCode, char byNewOreIndex, uint16_t dwOreSerial, char byOreDur, uint16_t dwBatteryLeftDurPoint);
void CPlayerSendMsg_MineStartResult862_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_MonsterAggroData864_wrapper(struct CPlayer* _this, struct CCharacter* pCharacter);
void CPlayerSendMsg_MoveError866_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_MoveNext868_wrapper(struct CPlayer* _this, bool bOtherSend);
void CPlayerSendMsg_MovePortal870_wrapper(struct CPlayer* _this, char byMapIndex, float* pfStartPos, char byZoneCode);
void CPlayerSendMsg_MoveToOwnStoneMapInform874_wrapper(struct CPlayer* _this, char byStoneMapMoveInfo);
void CPlayerSendMsg_MoveToOwnStoneMapResult876_wrapper(struct CPlayer* _this, char byRetCode, char byMapIndex, float* pos);
void CPlayerSendMsg_NPCLinkItemCheckResult878_wrapper(struct CPlayer* _this, char byResCode, struct _STORAGE_POS_INDIV* pStorage);
void CPlayerSendMsg_NewMovePotionResult880_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_NewViewOther882_wrapper(struct CPlayer* _this, char byViewType);
void CPlayerSendMsg_NotifyEffectForGetItem884_wrapper(struct CPlayer* _this, char byBoxType, unsigned int dwCharSerial, char* szCharName, struct _STORAGE_LIST::_db_con* pItem, bool bCircle);
void CPlayerSendMsg_NotifyGetExpInfo886_wrapper(struct CPlayer* _this, long double dOldExp, long double dAlterExp, long double dCurExp);
void CPlayerSendMsg_Notify_ExceptFromRaceRanking888_wrapper(struct CPlayer* _this, int bExcepted);
void CPlayerSendMsg_Notify_Get_Golden_Box890_wrapper(struct CPlayer* _this, char byBoxType, unsigned int dwCharSerial, char* szCharName, struct _STORAGE_LIST::_db_con* pItem, bool bCircle);
void CPlayerSendMsg_Notify_Gravity_Stone_Owner_Die892_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_Notify_Me_Get_Golden_Box894_wrapper(struct CPlayer* _this, char byBoxType, struct _STORAGE_LIST::_db_con* pItem);
void CPlayerSendMsg_NpcQuestHistoryInform896_wrapper(struct CPlayer* _this, char bySlotIndex);
void CPlayerSendMsg_NpcQuestListResult898_wrapper(struct CPlayer* _this, struct _NPCQuestIndexTempData* pQuestIndexData);
void CPlayerSendMsg_OffPartResult900_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_OfferSuggestResult902_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_OreCuttingResult904_wrapper(struct CPlayer* _this, char byErrCode, char byLeftOreNum, unsigned int dwConsumDalant);
void CPlayerSendMsg_OreIntoBagResult906_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wNewSerial, char byLendType, unsigned int dwLendTime);
void CPlayerSendMsg_OreTransferCount908_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_OtherShapeAll910_wrapper(struct CPlayer* _this, struct CPlayer* pDst);
void CPlayerSendMsg_OtherShapeError912_wrapper(struct CPlayer* _this, struct CPlayer* pDst, char byErrCode);
void CPlayerSendMsg_OtherShapePart914_wrapper(struct CPlayer* _this, struct CPlayer* pDst);
void CPlayerSendMsg_OtherShapePartEx_CashChange916_wrapper(struct CPlayer* _this, struct CPlayer* pDst, CPlayer::CashChangeStateFlag ServerData, CPlayer::CashChangeStateFlag ClinetData);
void CPlayerSendMsg_PartyAlterLootShareResult918_wrapper(struct CPlayer* _this, char byLootShareMode);
void CPlayerSendMsg_PartyDisjointResult920_wrapper(struct CPlayer* _this, char bSuccess);
void CPlayerSendMsg_PartyJoinApplicationQuestion922_wrapper(struct CPlayer* _this, struct CPlayer* pJoiner);
void CPlayerSendMsg_PartyJoinFailLevel924_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_PartyJoinInvitationQuestion926_wrapper(struct CPlayer* _this, uint16_t wJoinerIndex);
void CPlayerSendMsg_PartyJoinJoinerResult928_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_PartyJoinMemberResult930_wrapper(struct CPlayer* _this, struct CPartyPlayer* pJoiner, char byLootShareMode);
void CPlayerSendMsg_PartyLeaveCompulsionResult932_wrapper(struct CPlayer* _this, struct CPartyPlayer* pLeaver);
void CPlayerSendMsg_PartyLeaveSelfResult934_wrapper(struct CPlayer* _this, struct CPartyPlayer* pLeaver, bool bWorldExit);
void CPlayerSendMsg_PartyLockResult936_wrapper(struct CPlayer* _this, char byRet);
void CPlayerSendMsg_PartyLootItemInform938_wrapper(struct CPlayer* _this, unsigned int dwTakerSerial, char byTableCode, uint16_t wItemIndex, char byNum);
void CPlayerSendMsg_PartySuccessResult940_wrapper(struct CPlayer* _this, struct CPartyPlayer* pSuccessor);
void CPlayerSendMsg_PcRoomCharClass942_wrapper(struct CPlayer* _this, unsigned int dwPcRoomClassIndex);
void CPlayerSendMsg_PcRoomError944_wrapper(struct CPlayer* _this, char byErrorCode);
void CPlayerSendMsg_PostContent946_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwPostSerial, char* wszContent, char byTableCode, uint16_t wItemIndex, uint64_t dwDur, unsigned int dwLv, unsigned int dwGold);
void CPlayerSendMsg_PostDelete948_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwPostSerial);
void CPlayerSendMsg_PostDelivery950_wrapper(struct CPlayer* _this, char byIndex, unsigned int dwPostSerial, char* wszSendName, char* wszTitle, bool bItem, bool bGold, char byState);
void CPlayerSendMsg_PostItemGold952_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_PostReturn954_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwPostSerial, char* wszRecvName, char* wszTitle, char* wszContent, char byTableCode, uint16_t wItemIndex, uint64_t dwDur, unsigned int dwLv, unsigned int dwGold);
void CPlayerSendMsg_PostReturnConfirm956_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwPostSerial);
void CPlayerSendMsg_PostSendReply958_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_PotionDelayTime960_wrapper(struct CPlayer* _this, unsigned int* pdwPotionNextUseTime, unsigned int dwCurTime);
void CPlayerSendMsg_PotionDivision962_wrapper(struct CPlayer* _this, uint16_t wSerial, char byParentAmount, uint16_t wChildSerial, char byChildAmount, int nRet);
void CPlayerSendMsg_PotionSeparation964_wrapper(struct CPlayer* _this, uint16_t wParentSerial, char byParentAmount, uint16_t wChildSerial, char byChildAmount, int nRet);
void CPlayerSendMsg_PremiumCashItemUse966_wrapper(struct CPlayer* _this, uint16_t wSerial);
void CPlayerSendMsg_ProposeVoteResult968_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_PvpRankListVersionUp970_wrapper(struct CPlayer* _this, char byVersion);
void CPlayerSendMsg_QuestComplete972_wrapper(struct CPlayer* _this, char byQuestDBSlot);
void CPlayerSendMsg_QuestDownloadResult974_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_QuestFailure976_wrapper(struct CPlayer* _this, char byFailCode, char byQuestDBSlot);
void CPlayerSendMsg_QuestGiveUpResult978_wrapper(struct CPlayer* _this, char byReturnSlot);
void CPlayerSendMsg_QuestHistoryDownloadResult980_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_QuestProcess982_wrapper(struct CPlayer* _this, char byQuestDBSlot, char byActIndex, uint16_t wCount);
void CPlayerSendMsg_RACE_Greeting984_wrapper(struct CPlayer* _this, char* wszBossName, char* wszMsg);
void CPlayerSendMsg_RaceBattlePenelty986_wrapper(struct CPlayer* _this, int nAlterPoint, char byAlterType);
void CPlayerSendMsg_RaceBossCryMsg988_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_RaceTopInform990_wrapper(struct CPlayer* _this, bool bTop);
void CPlayerSendMsg_RadarCharSearchResult992_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_RadarDelayTime994_wrapper(struct CPlayer* _this, unsigned int dwDelay);
void CPlayerSendMsg_ReEnterAsk996_wrapper(struct CPlayer* _this, uint16_t wChannelIndex, unsigned int dwChannelSerial);
void CPlayerSendMsg_ReEnterDarkHoleResult998_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_RealMovePoint1000_wrapper(struct CPlayer* _this, int n);
void CPlayerSendMsg_Recover1002_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_RecvHSKQuest1004_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_RefeshGroupTargetPosition1006_wrapper(struct CPlayer* _this, char byGroupType);
void CPlayerSendMsg_RegistBindResult1008_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_ReleaseGroupTargetObjectResult1010_wrapper(struct CPlayer* _this, char byGroupType);
void CPlayerSendMsg_ReleaseSiegeModeResult1012_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_RemainOreRate1014_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_RemainTimeInform1016_wrapper(struct CPlayer* _this, int16_t iType, int lRemainTime, struct _SYSTEMTIME* pstEndDate);
void CPlayerSendMsg_ResDivision1018_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pStartOre, struct _STORAGE_LIST::_db_con* pTargetOre);
void CPlayerSendMsg_ResSeparation1020_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pStartOre, struct _STORAGE_LIST::_db_con* pNewOre);
void CPlayerSendMsg_ResultChangeTaxRate1022_wrapper(struct CPlayer* _this, char byRetCode, char byNextTax);
void CPlayerSendMsg_ResultNpcQuest1024_wrapper(struct CPlayer* _this, bool bSucc);
void CPlayerSendMsg_Resurrect1026_wrapper(struct CPlayer* _this, char byRet, bool bQuickPotion);
void CPlayerSendMsg_ResurrectInform1028_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_Revival1030_wrapper(struct CPlayer* _this, char byRet, bool bEquialZone);
void CPlayerSendMsg_RevivalOfJade1032_wrapper(struct CPlayer* _this, uint16_t wSuccRate);
void CPlayerSendMsg_RewardAddItem1034_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, char byReason);
void CPlayerSendMsg_SFDelayRequest1036_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_SelectClassResult1038_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wSelClassIndex);
void CPlayerSendMsg_SelectQuestReward1040_wrapper(struct CPlayer* _this, char byQuestDBSlot);
void CPlayerSendMsg_SelectWaitedQuest1042_wrapper(struct CPlayer* _this, char byEventType, unsigned int dwEventIndex, char byEventNodeIndex);
void CPlayerSendMsg_SellItemStoreResult1044_wrapper(struct CPlayer* _this, struct CItemStore* pStore, char byErrCode);
void CPlayerSendMsg_SetDPInform1046_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_SetFPInform1048_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_SetGroupMapPoint1050_wrapper(struct CPlayer* _this, char byRetCode, char byGroupType, char byMapCode, float* pzTar, char byRemain);
void CPlayerSendMsg_SetGroupTargetObjectResult1052_wrapper(struct CPlayer* _this, char byRetCode, char byGroupType);
void CPlayerSendMsg_SetHPInform1054_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_SetItemCheckResult1056_wrapper(struct CPlayer* _this, char byResult, unsigned int dwSetItem, char bySetEffectNum);
void CPlayerSendMsg_SetSPInform1058_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_SetTargetObjectResult1060_wrapper(struct CPlayer* _this, char byRetCode, bool bForce);
void CPlayerSendMsg_SkillResult1062_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, char bySkillIndex, int nSFLv);
void CPlayerSendMsg_SpecialDownloadResult1064_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_StartContSF1066_wrapper(struct CPlayer* _this, struct _sf_continous* pCont);
void CPlayerSendMsg_StartNewPos1068_wrapper(struct CPlayer* _this, char byMapInMode);
void CPlayerSendMsg_StartShopping1070_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_StatInform1072_wrapper(struct CPlayer* _this, char byStatIndex, unsigned int dwNewStat, char byReason);
void CPlayerSendMsg_StateInform1074_wrapper(struct CPlayer* _this, uint64_t dwStateFlag);
void CPlayerSendMsg_Stop1076_wrapper(struct CPlayer* _this, bool bAll);
void CPlayerSendMsg_StoreLimitItemAmountInfo1078_wrapper(struct CPlayer* _this, unsigned int dwStoreIndex, struct _limit_amount_info* pAmountInfo);
void CPlayerSendMsg_StoreListResult1080_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_TLStatusInfo1082_wrapper(struct CPlayer* _this, unsigned int dwFatigue, char wStatus);
void CPlayerSendMsg_TLStatusPenalty1084_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_TakeAddResult1086_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pItem);
void CPlayerSendMsg_TakeNewResult1088_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pItem);
void CPlayerSendMsg_TalikCrystalExchangeResult1090_wrapper(struct CPlayer* _this, char byRet, char byExchangeNum, struct _STORAGE_LIST::_db_con* pNewItem);
void CPlayerSendMsg_TargetObjectHPInform1092_wrapper(struct CPlayer* _this);
void CPlayerSendMsg_TeleportError1094_wrapper(struct CPlayer* _this, char byErrorCode, unsigned int dwMapIndex);
void CPlayerSendMsg_TestAttackResult1096_wrapper(struct CPlayer* _this, char byEffectCode, char byEffectIndex, uint16_t wBulletItemIndex, char byEffectLv, char byWeaponPart, int16_t* pzTar);
void CPlayerSendMsg_ThrowSkillResult1098_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, char bySkillIndex);
void CPlayerSendMsg_ThrowStorageResult1100_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_ThrowUnitResult1102_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, uint16_t wBulletIndex);
void CPlayerSendMsg_TowerContinue1104_wrapper(struct CPlayer* _this, uint16_t wItemSerial, struct CGuardTower* pTwr);
void CPlayerSendMsg_TransShipRenewTicketResult1106_wrapper(struct CPlayer* _this, char byErrCode);
void CPlayerSendMsg_TransformSiegeModeResult1108_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_TrunkChangPasswdResult1110_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_TrunkDownloadResult1112_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_TrunkEstResult1114_wrapper(struct CPlayer* _this, char byRetCode, unsigned int dwLeftDalant);
void CPlayerSendMsg_TrunkExtendResult1116_wrapper(struct CPlayer* _this, char byRetCode, char bySlotNum, unsigned int dwLeftDalant, unsigned int dwConsumDalant);
void CPlayerSendMsg_TrunkHintAnswerResult1118_wrapper(struct CPlayer* _this, char byRetCode, char* pwszPassword);
void CPlayerSendMsg_TrunkIoMoneyResult1120_wrapper(struct CPlayer* _this, char byRetCode, long double dTrunkDalant, long double dTrunkGold, unsigned int dwDalant, unsigned int dwGold, unsigned int dwFeeDalant);
void CPlayerSendMsg_TrunkIoResult1122_wrapper(struct CPlayer* _this, char byCase, char byRetCode, unsigned int dwLeftDalant, unsigned int dwConsumDanlant);
void CPlayerSendMsg_TrunkPotionDivision1124_wrapper(struct CPlayer* _this, uint16_t wSerial, uint16_t wParentAmount, uint16_t wChildSerial, uint16_t wChildAmount, int nRet);
void CPlayerSendMsg_TrunkPwHintIndexResult1126_wrapper(struct CPlayer* _this, char byRetCode, char byHintIndex);
void CPlayerSendMsg_TrunkResDivision1128_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pStartOre, struct _STORAGE_LIST::_db_con* pTargetOre);
void CPlayerSendMsg_UILock_FindPW_Result1130_wrapper(struct CPlayer* _this, char byRet, char* uszUILockPW, char byFindPassFailCount);
void CPlayerSendMsg_UILock_Init_Request_ToAccount1132_wrapper(struct CPlayer* _this, unsigned int dwSerial, char* uszUILockPW, uint16_t wUserIndex, char byHintIndex, char* uszHintAnswer);
void CPlayerSendMsg_UILock_Init_Result1134_wrapper(struct CPlayer* _this, char byRet);
void CPlayerSendMsg_UILock_Login_Result1136_wrapper(struct CPlayer* _this, char byRet, char byFailCount);
void CPlayerSendMsg_UILock_Update_Request_ToAccount1138_wrapper(struct CPlayer* _this, unsigned int dwSerial, char* uszUILockPW, uint16_t wUserIndex, char byHintIndex, char* uszHintAnswer);
void CPlayerSendMsg_UILock_Update_Result1140_wrapper(struct CPlayer* _this, char byRet);
void CPlayerSendMsg_UnitAlterFeeInform1142_wrapper(struct CPlayer* _this, char bySlotIndex, unsigned int dwPullingFee);
void CPlayerSendMsg_UnitBulletFillResult1144_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, uint16_t* pwBulletIndex, unsigned int* pdwConsumMoney);
void CPlayerSendMsg_UnitBulletReplaceResult1146_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_UnitDeliveryResult1148_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, unsigned int dwParkingUnitSerial, unsigned int dwPayDalant);
void CPlayerSendMsg_UnitDestroy1150_wrapper(struct CPlayer* _this, char bySlotIndex);
void CPlayerSendMsg_UnitForceReturnInform1152_wrapper(struct CPlayer* _this, char bySlotIndex, unsigned int dwDebt);
void CPlayerSendMsg_UnitFrameBuyResult1154_wrapper(struct CPlayer* _this, char byRetCode, char byFrameCode, char byUnitSlotIndex, uint16_t wKeyIndex, uint16_t wKeySerial, unsigned int* pdwConsumMoney);
void CPlayerSendMsg_UnitFrameRepairResult1156_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, unsigned int dwNewGauge, unsigned int dwConsumDalant);
void CPlayerSendMsg_UnitLeaveResult1158_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_UnitPackFillResult1160_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, char byFillNum, struct _unit_pack_fill_request_clzo::__list* pList, unsigned int* pdwConsumMoney);
void CPlayerSendMsg_UnitPartTuningResult1162_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, int* pnCost);
void CPlayerSendMsg_UnitReturnResult1164_wrapper(struct CPlayer* _this, char byRetCode, unsigned int dwPayDalant);
void CPlayerSendMsg_UnitRideChange1166_wrapper(struct CPlayer* _this, bool bTake, struct CParkingUnit* pUnit);
void CPlayerSendMsg_UnitSellResult1168_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, uint16_t wKeySerial, int nAddMoney, unsigned int dwTotalNonpay, unsigned int dwSumDalant, unsigned int dwSumGold);
void CPlayerSendMsg_UnitTakeResult1170_wrapper(struct CPlayer* _this, char byRetCode);
void CPlayerSendMsg_UpdateTLStatusInfo1172_wrapper(struct CPlayer* _this, unsigned int dwFatigue, char wStatus);
void CPlayerSendMsg_UsPotionResultOther1174_wrapper(struct CPlayer* _this, char byRetcode, uint16_t wPotionIndex, struct CPlayer* pUsePlayer, bool bCircle);
void CPlayerSendMsg_UseJadeResult1176_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wItemSerial);
void CPlayerSendMsg_UsePotionResult1178_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wSerial, char byLeftNum);
void CPlayerSendMsg_UseRadarResult1180_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wSerial, unsigned int dwDelay);
void CPlayerSendMsg_VoteResult1182_wrapper(struct CPlayer* _this, unsigned int dwMatterVoteSynKey, char byRetCode);
void CPlayerSendTargetMonsterSFContInfo1184_wrapper(struct CPlayer* _this);
void CPlayerSendTargetPlayerDamageContInfo1186_wrapper(struct CPlayer* _this);
void CPlayerSenseState1188_wrapper(struct CPlayer* _this);
void CPlayerSetAttackPart1190_wrapper(struct CPlayer* _this, int nAttactPart);
void CPlayerSetBattleMode1192_wrapper(struct CPlayer* _this, bool bAttack);
void CPlayerSetBindDummy1194_wrapper(struct CPlayer* _this, struct _dummy_position* pDummy);
void CPlayerSetBindMapData1196_wrapper(struct CPlayer* _this, struct CMapData* pMapData);
bool CPlayerSetBindPosition1198_wrapper(struct CPlayer* _this, struct CMapData* pMap, struct _dummy_position* pDummy);
void CPlayerSetCashAmount1200_wrapper(struct CPlayer* _this, int nAmount);
void CPlayerSetCntEnable1202_wrapper(struct CPlayer* _this, bool bSet);
bool CPlayerSetDP1204_wrapper(struct CPlayer* _this, int nDP, bool bOver);
int CPlayerSetDamage1206_wrapper(struct CPlayer* _this, int nDamage, struct CCharacter* pDst, int nDstLv, bool bCrt, int nAttackType, unsigned int dwAttackSerial, bool bJadeReturn);
void CPlayerSetEffectEquipCode1208_wrapper(struct CPlayer* _this, char byStorageCode, char bySlotIndex, char byCode);
void CPlayerSetEquipEffect1210_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_storage_con* pItem, bool bEquip);
void CPlayerSetEquipJadeEffect1212_wrapper(struct CPlayer* _this, int nParam, float fCurVal, bool bAdd);
bool CPlayerSetFP1214_wrapper(struct CPlayer* _this, int nFP, bool bOver);
void CPlayerSetGauge1216_wrapper(struct CPlayer* _this, int nParamCode, int nValue, bool bOver);
void CPlayerSetGrade1218_wrapper(struct CPlayer* _this, char byGrade);
bool CPlayerSetHP1220_wrapper(struct CPlayer* _this, int nHP, bool bOver);
void CPlayerSetHaveEffect1222_wrapper(struct CPlayer* _this, bool bLogin);
void CPlayerSetHaveEffectUseTime1224_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, bool bAdd);
void CPlayerSetLastAttBuff1226_wrapper(struct CPlayer* _this, bool bSet);
void CPlayerSetLevel1228_wrapper(struct CPlayer* _this, char byNewLevel);
void CPlayerSetLevelD1230_wrapper(struct CPlayer* _this, char byDownLevel);
void CPlayerSetMstHaveEffect1232_wrapper(struct CPlayer* _this, struct _ResourceItem_fld* pFld, struct _STORAGE_LIST::_db_con* pItem, bool bAdd, int nAlter);
void CPlayerSetMstPt1234_wrapper(struct CPlayer* _this, int nMstCode, float fVal, bool bAdd, int nWpType);
void CPlayerSetPotionActDelay1236_wrapper(struct CPlayer* _this, char byPotionClass, unsigned int dwCurrTime, unsigned int dwActDelay);
void CPlayerSetPvpPointLeak1238_wrapper(struct CPlayer* _this, long double dValue);
void CPlayerSetRankRate1240_wrapper(struct CPlayer* _this, uint16_t wRankRate, unsigned int dwRank);
bool CPlayerSetSP1242_wrapper(struct CPlayer* _this, int nSP, bool bOver);
void CPlayerSetShapeAllBuffer1244_wrapper(struct CPlayer* _this);
void CPlayerSetSiege1246_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pSiegeItem);
void CPlayerSetStateFlag1248_wrapper(struct CPlayer* _this);
void CPlayerSetStaticMember1250_wrapper();
bool CPlayerSetTarPos1252_wrapper(struct CPlayer* _this, float* fTarPos, bool bColl);
void CPlayerSetUseReleaseRaceBuffPotion1254_wrapper(struct CPlayer* _this);
void CPlayerSetVote1256_wrapper(struct CPlayer* _this, int nSerial);
void CPlayerSortPost1258_wrapper(struct CPlayer* _this, int nNumber);
void CPlayerSubActPoint1260_wrapper(struct CPlayer* _this, char byCode, unsigned int dwSub);
void CPlayerSubDalant1262_wrapper(struct CPlayer* _this, unsigned int dwSub);
void CPlayerSubGold1264_wrapper(struct CPlayer* _this, unsigned int dwSub);
void CPlayerSubPoint1266_wrapper(struct CPlayer* _this, unsigned int dwSub);
unsigned int CPlayerSumMinuteBetween1268_wrapper(struct CPlayer* _this, struct _SYSTEMTIME* tmLast, struct _SYSTEMTIME* tmLocal);
unsigned int CPlayerSumMinuteOne1270_wrapper(struct CPlayer* _this, struct _SYSTEMTIME* tm);
void CPlayerTakeGravityStone1272_wrapper(struct CPlayer* _this);
void CPlayerUpdateAuraSFCont1274_wrapper(struct CPlayer* _this);
void CPlayerUpdateChaosModeState1276_wrapper(struct CPlayer* _this, unsigned int dwCurTime);
bool CPlayerUpdateDelPost1278_wrapper(struct CPlayer* _this, unsigned int dwPostSerial, int nIndex);
void CPlayerUpdateLastCriTicket1280_wrapper(struct CPlayer* _this, uint16_t byCurrentYear, char byCurrentMonth, char byCurrentDay, char byCurrentHour, char byNumOfTime);
void CPlayerUpdateLastMetalTicket1282_wrapper(struct CPlayer* _this, uint16_t byCurrentYear, char byCurrentMonth, char byCurrentDay, char byCurrentHour, char byNumOfTime);
void CPlayerUpdatePost1284_wrapper(struct CPlayer* _this, unsigned int dwIndex);
void CPlayerUpdatePostAddLog1286_wrapper(struct CPlayer* _this, unsigned int dwIndex, bool bLog, int nItemKey);
void CPlayerUpdatePvpOrderView1288_wrapper(struct CPlayer* _this, int64_t tCurTime);
void CPlayerUpdatePvpPointLimiter1290_wrapper(struct CPlayer* _this, int64_t tCurTime);
void CPlayerUpdateReturnPost1292_wrapper(struct CPlayer* _this, unsigned int dwSerial);
void CPlayerUpdateVisualVer1294_wrapper(struct CPlayer* _this, CPlayer::CashChangeStateFlag byChangeFlagMask);
bool CPlayerUpdate_GoldPoint1296_wrapper(struct CPlayer* _this, unsigned int dwPoint);
void CPlayerUpdatedMasteryWriteHistory1298_wrapper(struct CPlayer* _this);
bool CPlayerWPActiveForce1300_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int nDamagedObjNum, struct _force_fld* pForceFld);
bool CPlayerWPActiveSkill1302_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int nDamagedObjNum, struct _skill_fld* pSkillFld, int nEffectCode);
bool CPlayerWeaponSFActive1304_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int* nDamagedObjNum, int* nShotNum, uint16_t wBulletSerial);
void CPlayer_AnimusReturn1306_wrapper(struct CPlayer* _this, char byReturnType);
int CPlayer_CalcMaxFP1308_wrapper(struct CPlayer* _this);
int CPlayer_CalcMaxHP1310_wrapper(struct CPlayer* _this);
int CPlayer_CalcMaxSP1312_wrapper(struct CPlayer* _this);
void CPlayer_CheckForcePullUnit1314_wrapper(struct CPlayer* _this);
uint16_t CPlayer_DeleteUnitKey1316_wrapper(struct CPlayer* _this, char bySlotIndex);
struct _ITEM_EFFECT* CPlayer_GetItemEffect1318_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem);
char CPlayer_GetPartyMemberInCircle1320_wrapper(struct CPlayer* _this, struct CPlayer** out_ppMember, int nMax, bool bOne);
bool CPlayer_LockUnitKey1322_wrapper(struct CPlayer* _this, char bySlotIndex, bool bLock);
struct _Quest_fld* CPlayer_Reward_Quest1324_wrapper(struct CPlayer* _this, struct _Quest_fld* pQuestFld, char byRewardItemIndex);
void CPlayer_TowerAllReturn1326_wrapper(struct CPlayer* _this, char byDestroyType, bool bForceReturn);
void CPlayer_TowerDestroy1328_wrapper(struct CPlayer* _this, struct CGuardTower* pTowerObj);
uint16_t CPlayer_TowerReturn1330_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pTowerItem);
void CPlayer_TrapDestroy1332_wrapper(struct CPlayer* _this, struct CTrap* pTrap, char byDestroyCode);
void CPlayer_TrapReturn1334_wrapper(struct CPlayer* _this, struct CTrap* pTrap, uint16_t wAddSerial);
void CPlayer_UnitDestroy1336_wrapper(struct CPlayer* _this, char byUnitSlot);
void CPlayer_UpdateUnitDebt1338_wrapper(struct CPlayer* _this, char bySlotIndex, unsigned int dwPull);
void CPlayer_check_dst_param_after_attack1340_wrapper(struct CPlayer* _this, int nTotalDam, struct CCharacter* pTarget);
bool CPlayer_check_embel_part1342_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pFixingItem);
bool CPlayer_check_equip_part1344_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pFixingItem);
int CPlayer_check_equipmastery_lim1346_wrapper(struct CPlayer* _this, int EquipMasteryCode);
int CPlayer_check_exp_after_attack1348_wrapper(struct CPlayer* _this, int nDamagedObjNum, struct _be_damaged_char* pList, struct CPartyModeKillMonsterExpNotify* kPartyExpNotify);
void CPlayer_check_guild_target_object1350_wrapper(struct CPlayer* _this);
void CPlayer_check_hp_send_party1352_wrapper(struct CPlayer* _this);
unsigned int CPlayer_check_mastery_cum_lim1354_wrapper(struct CPlayer* _this, char byMasteryClass, char byIndex);
unsigned int CPlayer_check_mastery_lim1356_wrapper(struct CPlayer* _this, char byMasteryClass, char byIndex);
void CPlayer_check_party_target_object1358_wrapper(struct CPlayer* _this);
void CPlayer_check_race_target_object1360_wrapper(struct CPlayer* _this);
void CPlayer_check_target_object1362_wrapper(struct CPlayer* _this);
int CPlayer_pre_check_force_attack1364_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfTarPos, uint16_t wForceItemSerial, struct _force_fld** ppForceFld, struct _STORAGE_LIST::_db_con** ppForceItem, uint16_t* pdwDecPoint, uint16_t wEffBtSerial, struct _STORAGE_LIST::_db_con** ppEffBtProp, struct _BulletItem_fld** ppfldEffBt);
int CPlayer_pre_check_in_guild_battle1366_wrapper(struct CPlayer* _this, struct CCharacter* pDst);
bool CPlayer_pre_check_in_guild_battle_race1368_wrapper(struct CPlayer* _this, struct CCharacter* pDst, bool bEqueal);
int CPlayer_pre_check_normal_attack1370_wrapper(struct CPlayer* _this, struct CCharacter* pDst, uint16_t wBulletSerial, bool bCount, struct _STORAGE_LIST::_db_con** ppBulletProp, struct _BulletItem_fld** ppfldBullet, uint16_t wEffBtSerial, struct _STORAGE_LIST::_db_con** ppEffBtProp, struct _BulletItem_fld** ppfldEffBt);
int CPlayer_pre_check_siege_attack1372_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, uint16_t wBulletSerial, struct _STORAGE_LIST::_db_con** ppBulletProp, struct _BulletItem_fld** ppfldBullet, uint16_t wEffBtSerial, struct _STORAGE_LIST::_db_con** ppEffBulletProp, struct _BulletItem_fld** ppfldEffBullet);
int CPlayer_pre_check_skill_attack1374_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byEffectCode, struct _skill_fld* pSkillFld, uint16_t wBulletSerial, struct _STORAGE_LIST::_db_con** ppBulletProp, struct _BulletItem_fld** ppfldBullet, int nEffectGroup, uint16_t* pdwDecPoint, uint16_t wEffBtSerial, struct _STORAGE_LIST::_db_con** ppEffBtProp, struct _BulletItem_fld** ppfldEffBt);
bool CPlayer_pre_check_skill_enable1376_wrapper(struct CPlayer* _this, struct _skill_fld* pSkillFld);
bool CPlayer_pre_check_skill_gradelimit1378_wrapper(struct CPlayer* _this, struct _skill_fld* pSkillFld);
int CPlayer_pre_check_unit_attack1380_wrapper(struct CPlayer* _this, struct CCharacter* pDst, char byWeaponPart, struct _UnitPart_fld** ppWeaponFld, struct _UnitBullet_fld** ppBulletFld, struct _unit_bullet_param** ppBulletParam);
bool CPlayer_pre_check_wpactive_force_attack1382_wrapper(struct CPlayer* _this);
bool CPlayer_pre_check_wpactive_skill_attack1384_wrapper(struct CPlayer* _this, char byEffectCode, struct _skill_fld* pSkillFld, uint16_t wBulletSerial, struct _STORAGE_LIST::_db_con** ppBulletProp, struct _BulletItem_fld** ppfldBullet);
void CPlayer_set_db_sf_effect1386_wrapper(struct CPlayer* _this, struct _SFCONT_DB_BASE* pDBBase);
void CPlayerapply_case_equip_std_effect1391_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, bool bEquip);
void CPlayerapply_case_equip_upgrade_effect1393_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, bool bEquip);
void CPlayerapply_have_item_std_effect1395_wrapper(struct CPlayer* _this, int nEffCode, float fVal, bool bAdd, int nDiffCnt);
void CPlayerapply_normal_item_std_effect1397_wrapper(struct CPlayer* _this, int nEffCode, float fVal, bool bEquip);
bool CPlayerdev_SetGuildGrade1399_wrapper(struct CPlayer* _this, char byGrade);
bool CPlayerdev_SetGuildGradeByGuildSerial1401_wrapper(struct CPlayer* _this, unsigned int dwGuildSerial, char byGrade);
bool CPlayerdev_SetGuildGradeByName1403_wrapper(struct CPlayer* _this, char* uszGuildName, char byGrade);
bool CPlayerdev_after_effect1405_wrapper(struct CPlayer* _this);
bool CPlayerdev_all_kill1407_wrapper(struct CPlayer* _this);
bool CPlayerdev_animus_recall_time_free1409_wrapper(struct CPlayer* _this, bool bFree);
bool CPlayerdev_avator_copy1411_wrapper(struct CPlayer* _this, char* pwszDstName);
bool CPlayerdev_change_class1413_wrapper(struct CPlayer* _this, char* pszClassCode);
bool CPlayerdev_cont_effect_del1415_wrapper(struct CPlayer* _this);
bool CPlayerdev_cont_effect_time1417_wrapper(struct CPlayer* _this, unsigned int dwSec);
bool CPlayerdev_dalant1419_wrapper(struct CPlayer* _this, unsigned int dwDalant);
bool CPlayerdev_die1421_wrapper(struct CPlayer* _this);
bool CPlayerdev_drop_item1423_wrapper(struct CPlayer* _this, char* pszItemCode, int nNum, char* pszUpTalCode, int nUpNum);
bool CPlayerdev_free_sf_by_class1425_wrapper(struct CPlayer* _this);
bool CPlayerdev_full_animus_gauge1427_wrapper(struct CPlayer* _this);
bool CPlayerdev_full_force1429_wrapper(struct CPlayer* _this);
bool CPlayerdev_full_point1431_wrapper(struct CPlayer* _this);
bool CPlayerdev_gold1433_wrapper(struct CPlayer* _this, unsigned int dwGold);
bool CPlayerdev_goto_monster1435_wrapper(struct CPlayer* _this, struct CMonster* pMon);
bool CPlayerdev_goto_npc1437_wrapper(struct CPlayer* _this, struct CMerchant* pNpc);
bool CPlayerdev_half_inven_amount1439_wrapper(struct CPlayer* _this, uint64_t dwAmount);
bool CPlayerdev_half_point1441_wrapper(struct CPlayer* _this);
bool CPlayerdev_init_monster1443_wrapper(struct CPlayer* _this);
bool CPlayerdev_inven_empty1445_wrapper(struct CPlayer* _this);
bool CPlayerdev_item_make_no_use_matrial1447_wrapper(struct CPlayer* _this, bool noUsingMatrial);
bool CPlayerdev_loot_bag1449_wrapper(struct CPlayer* _this);
bool CPlayerdev_loot_free1451_wrapper(struct CPlayer* _this, bool bFree);
bool CPlayerdev_loot_fullitem1453_wrapper(struct CPlayer* _this, char byLv);
bool CPlayerdev_loot_item1455_wrapper(struct CPlayer* _this, char* pszItemCode, int nNum, char* pszUpTalCode, int nUpNum);
bool CPlayerdev_loot_material1457_wrapper(struct CPlayer* _this);
bool CPlayerdev_loot_mine1459_wrapper(struct CPlayer* _this);
bool CPlayerdev_loot_tower1461_wrapper(struct CPlayer* _this);
bool CPlayerdev_lv1463_wrapper(struct CPlayer* _this, int nLv);
bool CPlayerdev_make_succ1465_wrapper(struct CPlayer* _this, bool bSucc);
bool CPlayerdev_max_level_ext1467_wrapper(struct CPlayer* _this, char byMaxLevel);
bool CPlayerdev_never_die1469_wrapper(struct CPlayer* _this, bool bSet);
bool CPlayerdev_quest_complete1471_wrapper(struct CPlayer* _this);
bool CPlayerdev_quest_complete_other1473_wrapper(struct CPlayer* _this, char* pwszCharName);
bool CPlayerdev_set_animus_exp1475_wrapper(struct CPlayer* _this, uint64_t dwExpPoint);
bool CPlayerdev_set_animus_lv1477_wrapper(struct CPlayer* _this, int nAnimusLv);
bool CPlayerdev_set_hp1479_wrapper(struct CPlayer* _this, float prob);
bool CPlayerdev_trap_attack_grade1481_wrapper(struct CPlayer* _this, int nPoint);
bool CPlayerdev_up_all1483_wrapper(struct CPlayer* _this, int nCum);
bool CPlayerdev_up_all_pt1485_wrapper(struct CPlayer* _this, int nLv);
bool CPlayerdev_up_cashbag1487_wrapper(struct CPlayer* _this, long double dPoint);
bool CPlayerdev_up_forceitem1489_wrapper(struct CPlayer* _this, int nCum);
bool CPlayerdev_up_forcemastery1491_wrapper(struct CPlayer* _this, int nCum);
bool CPlayerdev_up_mastery1493_wrapper(struct CPlayer* _this, int nMasteryCode, int nMasteryIndex, int nLv);
bool CPlayerdev_up_pvp1495_wrapper(struct CPlayer* _this, long double dPoint);
bool CPlayerdev_up_skill1497_wrapper(struct CPlayer* _this, char* pszSkillCode, int nCum);
bool CPlayerdev_view_boss1499_wrapper(struct CPlayer* _this);
bool CPlayerdev_view_method1501_wrapper(struct CPlayer* _this, char* pwszDstName);
void CPlayermake_force_attack_param1503_wrapper(struct CPlayer* _this, struct CCharacter* pDst, struct _force_fld* pForceFld, struct _STORAGE_LIST::_db_con* pForceItem, float* pTar, struct _attack_param* pAP, struct _STORAGE_LIST::_db_con* pEffBulletItem, float fAddEffBtFc);
void CPlayermake_gen_attack_param1505_wrapper(struct CPlayer* _this, struct CCharacter* pDst, char byPart, struct _BulletItem_fld* pBulletFld, float fAddBulletFc, struct _attack_param* pAP, struct _BulletItem_fld* pEffBtFld, float fAddEffBtFc);
void CPlayermake_siege_attack_param1507_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byPart, struct _BulletItem_fld* pBulletFld, float fAddBulletFc, struct _attack_param* pAP, struct _BulletItem_fld* pEffBulletFld, float fAddEffBtFc);
void CPlayermake_skill_attack_param1509_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byEffectCode, struct _skill_fld* pSkillFld, int nAttType, struct _STORAGE_LIST::_db_con* pBulletItem, float fAddBulletFc, struct _attack_param* pAP, struct _STORAGE_LIST::_db_con* pEffBulletItem, float fAddEffBulletFc);
void CPlayermake_unit_attack_param1511_wrapper(struct CPlayer* _this, struct CCharacter* pDst, struct _UnitPart_fld* pWeaponFld, float fAddBulletFc, struct _attack_param* pAP);
void CPlayermake_wpactive_force_attack_param1513_wrapper(struct CPlayer* _this, struct CCharacter* pDst, struct _force_fld* pForceFld, float* pfAttackPos, struct _attack_param* pAP);
void CPlayermake_wpactive_skill_attack_param1515_wrapper(struct CPlayer* _this, struct CCharacter* pDst, struct _skill_fld* pSkillFld, float* pfAttackPos, char byEffectCode, int nAttType, struct _STORAGE_LIST::_db_con* pBulletItem, float fAddBulletFc, struct _attack_param* pAP, int* nShotNum);
bool CPlayermgr_MaxAttackPoint1517_wrapper(struct CPlayer* _this, int nMax);
bool CPlayermgr_TrunkInit1519_wrapper(struct CPlayer* _this);
bool CPlayermgr_all_item_muzi1521_wrapper(struct CPlayer* _this, int nLv);
bool CPlayermgr_change_degree1523_wrapper(struct CPlayer* _this, int nDegree);
bool CPlayermgr_defense_item_grace1525_wrapper(struct CPlayer* _this, char byItemCode, int nLv);
bool CPlayermgr_destroy_system_tower1527_wrapper(struct CPlayer* _this);
bool CPlayermgr_dungeon_pass1529_wrapper(struct CPlayer* _this);
bool CPlayermgr_exit_keeper1531_wrapper(struct CPlayer* _this);
bool CPlayermgr_exit_stone1533_wrapper(struct CPlayer* _this);
bool CPlayermgr_free_ride_ship1535_wrapper(struct CPlayer* _this);
bool CPlayermgr_gotoCoordinates1537_wrapper(struct CPlayer* _this, char* pszMapCode, float fX, float fY, float fZ);
bool CPlayermgr_gotoDstCoordinates1539_wrapper(struct CPlayer* _this, char* pwszDstName, char* pszMapCode, float fX, float fY, float fZ);
bool CPlayermgr_goto_mine1541_wrapper(struct CPlayer* _this);
bool CPlayermgr_goto_shipport1543_wrapper(struct CPlayer* _this, int nRaceCode, int nPort);
bool CPlayermgr_goto_stone1545_wrapper(struct CPlayer* _this, char byRaceCode);
bool CPlayermgr_goto_store1547_wrapper(struct CPlayer* _this, int nRaceCode, char* pszNPCName);
bool CPlayermgr_holykeeper_start1549_wrapper(struct CPlayer* _this, int nRace);
bool CPlayermgr_holystone_start1551_wrapper(struct CPlayer* _this, int nNumOfTime);
bool CPlayermgr_item_telekinesis1553_wrapper(struct CPlayer* _this);
bool CPlayermgr_kick1555_wrapper(struct CPlayer* _this, char* pwszCharName);
bool CPlayermgr_make_system_tower1557_wrapper(struct CPlayer* _this, char* pszTowerCode);
bool CPlayermgr_matchless1559_wrapper(struct CPlayer* _this, bool bMatchless);
bool CPlayermgr_pass_sch_one_step1561_wrapper(struct CPlayer* _this);
bool CPlayermgr_recall_guild_player1563_wrapper(struct CPlayer* _this, char* wszDestCharName);
bool CPlayermgr_recall_mon1565_wrapper(struct CPlayer* _this, char* pszMonCode, int nCreateNum);
bool CPlayermgr_recall_party_player1567_wrapper(struct CPlayer* _this, char* wszDestCharName);
bool CPlayermgr_recall_player1569_wrapper(struct CPlayer* _this, char* pwszCharName);
bool CPlayermgr_resurrect_player1571_wrapper(struct CPlayer* _this, char* pwszCharName);
bool CPlayermgr_set_animus_attack_point1573_wrapper(struct CPlayer* _this, int nPoint);
bool CPlayermgr_tracing1575_wrapper(struct CPlayer* _this, bool bOn);
bool CPlayermgr_user_ban1577_wrapper(struct CPlayer* _this, char* uszCharName, int iPeriod, char* uszReason, char byBlockType);
bool CPlayermgr_whisper1579_wrapper(struct CPlayer* _this, char* pwszMsg);
void CPlayerpc_AddBag1581_wrapper(struct CPlayer* _this, uint16_t wBagItemSerial);
void CPlayerpc_AlterItemSlotRequest1583_wrapper(struct CPlayer* _this, char byNum, struct _alter_item_slot_request_clzo::__list* pList);
void CPlayerpc_AlterLinkBoardSlotRequest1585_wrapper(struct CPlayer* _this, char byNum, struct _alter_link_slot_request_clzo::__list* pList, char byLBLock);
void CPlayerpc_AlterWindowInfoRequest1587_wrapper(struct CPlayer* _this, unsigned int* pdwSkill, unsigned int* pdwForce, unsigned int* pdwChar, unsigned int* pdwAnimus, unsigned int dwInven, unsigned int* pdwInvenBag);
void CPlayerpc_AnimusCommandRequest1589_wrapper(struct CPlayer* _this, char byCommandCode);
void CPlayerpc_AnimusInvenChange1591_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem, uint16_t wReplaceSerial);
void CPlayerpc_AnimusRecallRequest1593_wrapper(struct CPlayer* _this, uint16_t wAnimusItemSerial, uint16_t wAnimusClientHP, uint16_t wAnimusClientFP);
void CPlayerpc_AnimusReturnRequest1595_wrapper(struct CPlayer* _this);
void CPlayerpc_AnimusTargetRequest1597_wrapper(struct CPlayer* _this, char byObjectID, uint16_t wObjectIndex, unsigned int dwObjectSerial);
void CPlayerpc_AwayPartyJoinInvitationAnswer1599_wrapper(struct CPlayer* _this, struct _CLID* pidBoss, char byRetCode);
void CPlayerpc_AwaypartyInvitationRequest1601_wrapper(struct CPlayer* _this, char* pwszCharName);
void CPlayerpc_BackTowerRequest1603_wrapper(struct CPlayer* _this, unsigned int dwTowerObjSerial);
void CPlayerpc_BackTrapRequest1605_wrapper(struct CPlayer* _this, unsigned int dwTrapObjSerial, uint16_t wAddSerial);
void CPlayerpc_BillingInfoRequest1607_wrapper(struct CPlayer* _this);
void CPlayerpc_BriefPass1609_wrapper(struct CPlayer* _this, char byQuestSlotIndex);
void CPlayerpc_BuddyAddAnswer1611_wrapper(struct CPlayer* _this, bool bAccept, uint16_t wAskerIndex, unsigned int dwAskerSerial);
void CPlayerpc_BuddyAddRequest1613_wrapper(struct CPlayer* _this, uint16_t wDstIndex, unsigned int dwDstSerial, char* pwszDstName);
void CPlayerpc_BuddyDelRequest1615_wrapper(struct CPlayer* _this, unsigned int dwSerial);
void CPlayerpc_BuddyDownloadRequest1617_wrapper(struct CPlayer* _this);
void CPlayerpc_BuyItemStore1619_wrapper(struct CPlayer* _this, struct CItemStore* pStore, char byOfferNum, struct _buy_store_request_clzo::_list* pList, int bUseNPCLinkIntem);
char CPlayerpc_CanSelectClassRequest1621_wrapper(struct CPlayer* _this, char* pIsRealClassUp);
void CPlayerpc_CastVoteRequest1623_wrapper(struct CPlayer* _this, int nVoteSerial, char byCode);
void CPlayerpc_ChangeModeType1625_wrapper(struct CPlayer* _this, int nModeType, int nStandType);
bool CPlayerpc_CharacterRenameCash1627_wrapper(struct CPlayer* _this, bool bChange, struct _STORAGE_POS_INDIV* pItem, char* strCharacterName);
char CPlayerpc_CharacterRenameCheck1629_wrapper(struct CPlayer* _this, char* strCharacterName);
void CPlayerpc_ChatAllRequest1631_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatCircleRequest1633_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatFarRequest1635_wrapper(struct CPlayer* _this, char* pwszName, char* pwszChatData);
void CPlayerpc_ChatGmNoticeRequest1637_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatGuildEstSenRequest1639_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatGuildRequest1641_wrapper(struct CPlayer* _this, unsigned int dwDstSerial, char* pwszChatData);
void CPlayerpc_ChatMapRequest1643_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatMgrWhisperRequest1645_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatMultiFarRequest1647_wrapper(struct CPlayer* _this, char byDstNum, struct _w_name* pDstName, char* pwszMsg);
void CPlayerpc_ChatOperatorRequest1649_wrapper(struct CPlayer* _this, char byRaceCode, char* pwszChatData);
void CPlayerpc_ChatPartyRequest1651_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatRaceBossCryRequest1653_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatRaceBossRequest1655_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatRaceRequest1657_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatRePresentationRequest1659_wrapper(struct CPlayer* _this, char* pwszChatData);
void CPlayerpc_ChatTradeRequestMsg1661_wrapper(struct CPlayer* _this, char bySubType, char* pwszTradeMsg);
void CPlayerpc_ClassSkillRequest1663_wrapper(struct CPlayer* _this, uint16_t wSkillIndex, struct _CHRID* pidDst, uint16_t* pConsumeSerial);
void CPlayerpc_CombineItem1665_wrapper(struct CPlayer* _this, uint16_t wManualIndex, char byMaterialNum, struct _STORAGE_POS_INDIV* pipMaterials, uint16_t wOverlapSerial);
void CPlayerpc_CombineItemEx1667_wrapper(struct CPlayer* _this, struct _combine_ex_item_request_clzo* pRecv);
void CPlayerpc_CombineItemExAccept1669_wrapper(struct CPlayer* _this, struct _combine_ex_item_accept_request_clzo* pRecv);
void CPlayerpc_CuttingComplete1671_wrapper(struct CPlayer* _this, char byNpcRace);
void CPlayerpc_DTradeAddRequest1673_wrapper(struct CPlayer* _this, char bySlotIndex, char byStorageCode, unsigned int dwSerial, char byAmount);
void CPlayerpc_DTradeAnswerRequest1675_wrapper(struct CPlayer* _this, struct _CLID* pidAsker);
void CPlayerpc_DTradeAskRequest1677_wrapper(struct CPlayer* _this, uint16_t wDstIndex);
void CPlayerpc_DTradeBetRequest1679_wrapper(struct CPlayer* _this, char byMoneyUnit, unsigned int dwBetAmount);
void CPlayerpc_DTradeCancleRequest1681_wrapper(struct CPlayer* _this);
void CPlayerpc_DTradeDelRequest1683_wrapper(struct CPlayer* _this, char bySlotIndex);
void CPlayerpc_DTradeLockRequest1685_wrapper(struct CPlayer* _this);
void CPlayerpc_DTradeOKRequest1687_wrapper(struct CPlayer* _this, unsigned int* pdwKey);
void CPlayerpc_DarkHoleAnswerReenterRequest1689_wrapper(struct CPlayer* _this, bool bEnter, uint16_t wChannelIndex, unsigned int dwChannelSerial);
void CPlayerpc_DarkHoleClearOutRequest1691_wrapper(struct CPlayer* _this);
void CPlayerpc_DarkHoleEnterRequest1693_wrapper(struct CPlayer* _this, uint16_t wHoleIndex, unsigned int dwHoleSerial);
void CPlayerpc_DarkHoleGiveupOutRequest1695_wrapper(struct CPlayer* _this);
void CPlayerpc_DarkHoleOpenRequest1697_wrapper(struct CPlayer* _this, unsigned int dwItemSerial);
void CPlayerpc_DowngradeItem1699_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pposTalik, struct _STORAGE_POS_INDIV* pposToolItem, struct _STORAGE_POS_INDIV* pposUpgItem);
void CPlayerpc_EmbellishPart1701_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem, uint16_t wChangeSerial);
void CPlayerpc_EquipPart1703_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem);
void CPlayerpc_ExchangeDalantForGold1705_wrapper(struct CPlayer* _this, unsigned int dwDalant);
void CPlayerpc_ExchangeGoldForDalant1707_wrapper(struct CPlayer* _this, unsigned int dwGold);
void CPlayerpc_ExchangeGoldForPvP1709_wrapper(struct CPlayer* _this, unsigned int dwGold);
void CPlayerpc_ExchangeItem1711_wrapper(struct CPlayer* _this, uint16_t wManualIndex, uint16_t wItemSerial);
void CPlayerpc_ExitWorldRequest1713_wrapper(struct CPlayer* _this);
void CPlayerpc_ForceInvenChange1715_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem, uint16_t wReplaceSerial);
void CPlayerpc_ForceRequest1717_wrapper(struct CPlayer* _this, uint16_t wForceSerial, struct _CHRID* pidDst, uint16_t* pConsumeSerial);
void CPlayerpc_GestureRequest1719_wrapper(struct CPlayer* _this, char byGestureType);
bool CPlayerpc_GiveItem1721_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* kItem, char* szReason, bool bDrop);
void CPlayerpc_GotoAvatorRequest1723_wrapper(struct CPlayer* _this, char* pwszAvatorName);
void CPlayerpc_GotoBasePortalRequest1725_wrapper(struct CPlayer* _this, uint16_t wItemSerial);
void CPlayerpc_GuildBattleBlock1727_wrapper(struct CPlayer* _this, bool bBlock);
void CPlayerpc_GuildCancelSuggestRequest1729_wrapper(struct CPlayer* _this, unsigned int dwMatterVoteSynKey);
void CPlayerpc_GuildDownLoadRequest1731_wrapper(struct CPlayer* _this);
void CPlayerpc_GuildEstablishRequest1733_wrapper(struct CPlayer* _this, char* pwszGuildName);
void CPlayerpc_GuildHonorListRequest1735_wrapper(struct CPlayer* _this, char byUI);
void CPlayerpc_GuildJoinAcceptRequest1737_wrapper(struct CPlayer* _this, unsigned int dwApplierSerial, bool bAccept);
void CPlayerpc_GuildJoinApplyCancelRequest1739_wrapper(struct CPlayer* _this);
void CPlayerpc_GuildJoinApplyRequest1741_wrapper(struct CPlayer* _this, char* pwszGuildName);
void CPlayerpc_GuildListRequest1743_wrapper(struct CPlayer* _this, char byPage);
void CPlayerpc_GuildManageRequest1745_wrapper(struct CPlayer* _this, char byType, unsigned int dwDst, unsigned int dwObj1, unsigned int dwObj2, unsigned int dwObj3);
void CPlayerpc_GuildNextHonorListRequest1747_wrapper(struct CPlayer* _this);
void CPlayerpc_GuildOfferSuggestRequest1749_wrapper(struct CPlayer* _this, char byMatterType, unsigned int dwMatterDst, char* pwszComment, unsigned int dwMatterObj1, unsigned int dwMatterObj2, unsigned int dwMatterObj3);
void CPlayerpc_GuildPushMoneyRequest1751_wrapper(struct CPlayer* _this, unsigned int dwPushDalant, unsigned int dwPushGold);
void CPlayerpc_GuildQueryInfoRequest1753_wrapper(struct CPlayer* _this, unsigned int dwGuildSerial);
void CPlayerpc_GuildRoomEnterRequest1755_wrapper(struct CPlayer* _this, struct _guildroom_enter_request_clzo* pProtocol);
void CPlayerpc_GuildRoomOutRequest1757_wrapper(struct CPlayer* _this, struct _guildroom_out_request_clzo* pProtocol);
void CPlayerpc_GuildRoomRentRequest1759_wrapper(struct CPlayer* _this, struct _guildroom_rent_request_clzo* pProtocol);
void CPlayerpc_GuildRoomRestTimeRequest1761_wrapper(struct CPlayer* _this, struct _guildroom_resttime_request_clzo* pProtocol);
void CPlayerpc_GuildSelfLeaveRequest1763_wrapper(struct CPlayer* _this);
void CPlayerpc_GuildSetHonorRequest1765_wrapper(struct CPlayer* _this, struct _guild_honor_set_request_clzo* pData);
void CPlayerpc_GuildVoteRequest1767_wrapper(struct CPlayer* _this, unsigned int dwMatterVoteSynKey, char byVoteCode);
char CPlayerpc_InitClass1769_wrapper(struct CPlayer* _this);
char CPlayerpc_InitClassRequest1771_wrapper(struct CPlayer* _this);
void CPlayerpc_LimitItemNumRequest1773_wrapper(struct CPlayer* _this, unsigned int dwStoreIndex);
void CPlayerpc_LinkBoardRequest1775_wrapper(struct CPlayer* _this);
void CPlayerpc_MacroUpdate1777_wrapper(struct CPlayer* _this, char* pBuf);
void CPlayerpc_MakeItem1779_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pipMakeTool, uint16_t wManualIndex, char byMaterialNum, struct _STORAGE_POS_INDIV* pipMaterials);
void CPlayerpc_MakeTowerRequest1781_wrapper(struct CPlayer* _this, uint16_t wSkillIndex, uint16_t wTowerItemSerial, char byMaterialNum, struct _make_tower_request_clzo::__material* pMaterial, float* pfPos, uint16_t* pConsumeSerial);
void CPlayerpc_MakeTrapRequest1783_wrapper(struct CPlayer* _this, uint16_t wSkillIndex, uint16_t wTrapItemSerial, float* pfPos, uint16_t* pConsumeSerial);
void CPlayerpc_MineCancle1785_wrapper(struct CPlayer* _this);
void CPlayerpc_MineComplete1787_wrapper(struct CPlayer* _this);
void CPlayerpc_MineStart1789_wrapper(struct CPlayer* _this, char byMineIndex, char byOreIndex, uint16_t wBatterySerial);
void CPlayerpc_MoveModeChangeRequest1791_wrapper(struct CPlayer* _this, char byMoveType);
void CPlayerpc_MoveNext1793_wrapper(struct CPlayer* _this, char byMoveType, float* pfCur, float* pfTar, char byDirect);
void CPlayerpc_MovePortal1795_wrapper(struct CPlayer* _this, int nPortalIndex, uint16_t* pConsumeSerial);
void CPlayerpc_MoveStop1797_wrapper(struct CPlayer* _this, float* pfCur);
void CPlayerpc_MoveToOwnStoneMapRequest1799_wrapper(struct CPlayer* _this);
bool CPlayerpc_NPCLinkCheckItemRequest1801_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pStorage);
char CPlayerpc_NPCLinkCheckItemRequest_Check1803_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pStorage);
char CPlayerpc_NPCLinkCheckItemRequest_Use1805_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pStorage);
void CPlayerpc_NewPosStart1807_wrapper(struct CPlayer* _this);
void CPlayerpc_NotifyRaceBossCryMsg1809_wrapper(struct CPlayer* _this);
void CPlayerpc_NuclearAfterEffect1811_wrapper(struct CPlayer* _this);
void CPlayerpc_OffPart1813_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem);
void CPlayerpc_OreCutting1815_wrapper(struct CPlayer* _this, uint16_t wOreSerial, char byProcessNum);
void CPlayerpc_OreIntoBag1817_wrapper(struct CPlayer* _this, uint16_t wResIndex, uint16_t wSerial, char byAddAmount);
void CPlayerpc_PartyAlterLootShareReqeuest1819_wrapper(struct CPlayer* _this, char byLootShareMode);
void CPlayerpc_PartyDisJointReqeuest1821_wrapper(struct CPlayer* _this);
void CPlayerpc_PartyJoinApplication1823_wrapper(struct CPlayer* _this, uint16_t wBossIndex);
void CPlayerpc_PartyJoinApplicationAnswer1825_wrapper(struct CPlayer* _this, struct _CLID* pidApplicant);
void CPlayerpc_PartyJoinInvitation1827_wrapper(struct CPlayer* _this, uint16_t wDstIndex);
void CPlayerpc_PartyJoinInvitationAnswer1829_wrapper(struct CPlayer* _this, struct _CLID* pidBoss);
void CPlayerpc_PartyLeaveCompulsionReqeuest1831_wrapper(struct CPlayer* _this, unsigned int dwExiterSerial);
void CPlayerpc_PartyLeaveSelfReqeuest1833_wrapper(struct CPlayer* _this);
void CPlayerpc_PartyLockReqeuest1835_wrapper(struct CPlayer* _this, bool bLock);
void CPlayerpc_PartyReqBlock1837_wrapper(struct CPlayer* _this, bool bBlock);
void CPlayerpc_PartySuccessionReqeuest1839_wrapper(struct CPlayer* _this, unsigned int dwSuccessorSerial);
void CPlayerpc_PlayAttack_Force1841_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAreaPos, uint16_t wForceSerial, uint16_t* pConsumeSerial, uint16_t wEffBtSerial);
void CPlayerpc_PlayAttack_Gen1843_wrapper(struct CPlayer* _this, struct CCharacter* pDst, char byAttPart, uint16_t wBulletSerial, uint16_t wEffBtSerial, bool bCount);
void CPlayerpc_PlayAttack_SelfDestruction1845_wrapper(struct CPlayer* _this);
void CPlayerpc_PlayAttack_Siege1847_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byAttPart, uint16_t wBulletSerial, uint16_t wEffBtSerial);
void CPlayerpc_PlayAttack_Skill1849_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byEffectCode, uint16_t wSkillIndex, uint16_t wBulletSerial, uint16_t* pConsumeSerial, uint16_t wEffBtSerial);
void CPlayerpc_PlayAttack_Test1851_wrapper(struct CPlayer* _this, char byEffectCode, char byEffectIndex, uint16_t wBulletItemSerial, char byWeaponPart, int16_t* pzTar);
void CPlayerpc_PlayAttack_Unit1853_wrapper(struct CPlayer* _this, struct CCharacter* pDst, char byWeaponPart);
void CPlayerpc_PostContentRequest1855_wrapper(struct CPlayer* _this, unsigned int dwIndex);
void CPlayerpc_PostDeleteRequest1857_wrapper(struct CPlayer* _this, unsigned int dwIndex);
void CPlayerpc_PostItemGoldRequest1859_wrapper(struct CPlayer* _this, unsigned int dwIndex);
void CPlayerpc_PostListRequest1861_wrapper(struct CPlayer* _this);
void CPlayerpc_PostReturnConfirmRequest1863_wrapper(struct CPlayer* _this, unsigned int dwPostSerial);
void CPlayerpc_PotionDivision1865_wrapper(struct CPlayer* _this, uint16_t wSerial, uint16_t wTarSerial, char byAmount);
void CPlayerpc_PotionSeparation1867_wrapper(struct CPlayer* _this, uint16_t wSerial, char byAmount);
void CPlayerpc_PotionUseTrunkExtend1869_wrapper(struct CPlayer* _this);
void CPlayerpc_ProposeVoteRequest1871_wrapper(struct CPlayer* _this, char byLimGrade, char* pwszCont);
void CPlayerpc_PvpCashRecorver1873_wrapper(struct CPlayer* _this, unsigned int dwItemSerial, char byItemCnt);
void CPlayerpc_QuestGiveupRequest1875_wrapper(struct CPlayer* _this, char byQuestDBSlot);
bool CPlayerpc_RadarCharInfo1877_wrapper(struct CPlayer* _this);
void CPlayerpc_RealMovPos1879_wrapper(struct CPlayer* _this, float* pfCur);
void CPlayerpc_RefreshGroupTargetPosition1881_wrapper(struct CPlayer* _this, char byGroupType, struct CGameObject* pObject);
void CPlayerpc_RegistBind1883_wrapper(struct CPlayer* _this, struct CItemStore* pStore);
void CPlayerpc_ReleaseGroupTargetObjectRequest1885_wrapper(struct CPlayer* _this, char byGroupType);
void CPlayerpc_ReleaseSiegeModeRequest1887_wrapper(struct CPlayer* _this);
void CPlayerpc_ReleaseTargetObjectRequest1889_wrapper(struct CPlayer* _this);
char CPlayerpc_RenameItemNConditionCheck1891_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItemInfo, struct _STORAGE_LIST::_db_con** ppItem);
void CPlayerpc_RequestChangeTaxRate1893_wrapper(struct CPlayer* _this, char byTaxRate);
void CPlayerpc_RequestDialogWithNPC1895_wrapper(struct CPlayer* _this, struct CItemStore* pStore);
void CPlayerpc_RequestPatriarchPunishment1897_wrapper(struct CPlayer* _this, char byType, char* pwszName, char* pwszCont);
void CPlayerpc_RequestQuestFromNPC1899_wrapper(struct CPlayer* _this, struct CItemStore* pStore, unsigned int dwNPCQuestIndex);
void CPlayerpc_RequestQuestListFromNPC1901_wrapper(struct CPlayer* _this, struct CItemStore* pStore);
void CPlayerpc_RequestTaxRate1903_wrapper(struct CPlayer* _this);
void CPlayerpc_RequestUILockCertify1905_wrapper(struct CPlayer* _this, struct CUserDB* pUserDB, char* uszUILockPW);
void CPlayerpc_RequestUILockFindPW1907_wrapper(struct CPlayer* _this, struct CUserDB* pUserDB, char* uszHintAnswer);
void CPlayerpc_RequestUILockInit1909_wrapper(struct CPlayer* _this, struct CUserDB* pUserDB, char* szUILockPW, char* szUILockPW_Confirm, char byUILock_HintIndex, char* uszUILock_HintAnswer);
void CPlayerpc_RequestUILockUpdate1911_wrapper(struct CPlayer* _this, char* uszUILockPWOld, char* uszUILockPW, char* uszUILockPW_Confirm, char byUILock_HintIndex, char* uszUILock_HintAnswer);
void CPlayerpc_RequestWatchingWithNPC1913_wrapper(struct CPlayer* _this, struct CItemStore* pStore);
void CPlayerpc_ResDivision1915_wrapper(struct CPlayer* _this, uint16_t wStartSerial, uint16_t wTarSerial, char byMoveAmount);
void CPlayerpc_ResSeparation1917_wrapper(struct CPlayer* _this, uint16_t wStartSerial, char byMoveAmount);
bool CPlayerpc_Resurrect1919_wrapper(struct CPlayer* _this, bool bQuickPotion);
void CPlayerpc_Revival1921_wrapper(struct CPlayer* _this, bool bUseableJade);
void CPlayerpc_SelectClassRequest1923_wrapper(struct CPlayer* _this, uint16_t wSelClassIndex, char bySelectRewardItem);
void CPlayerpc_SelectQuestAfterHappenEvent1925_wrapper(struct CPlayer* _this, char bySelectIndex);
void CPlayerpc_SelectQuestReward1927_wrapper(struct CPlayer* _this, char byQuestDBSlot, char bySelectItemSlotIndex, char bySelectLinkQuestIndex);
void CPlayerpc_SellItemStore1929_wrapper(struct CPlayer* _this, struct CItemStore* pStore, char byOfferNum, struct _sell_store_request_clzo::_list* pList, int bUseNPCLinkIntem);
void CPlayerpc_SetGroupMapPointRequest1931_wrapper(struct CPlayer* _this, char byGroupType, float* pzTar);
void CPlayerpc_SetGroupTargetObjectRequest1933_wrapper(struct CPlayer* _this, struct CGameObject* pTar, unsigned int dwSerial, char byGroupType);
void CPlayerpc_SetInGuildBattle1935_wrapper(struct CPlayer* _this, bool bInGuildBattle, char byColorInx);
bool CPlayerpc_SetItemCheckRequest1937_wrapper(struct CPlayer* _this, unsigned int dwSetItem, char bySetItemNum, char bySetEffectNum, bool bSet);
void CPlayerpc_SetRaceBossCryMsg1939_wrapper(struct CPlayer* _this, char bySlot, char* pwszCryMsg);
void CPlayerpc_SetTargetObjectRequest1941_wrapper(struct CPlayer* _this, struct CGameObject* pTar, unsigned int dwSerial, bool bForce);
void CPlayerpc_SkillRequest1943_wrapper(struct CPlayer* _this, char bySkillIndex, struct _CHRID* pidDst, uint16_t* pConsumeSerial);
void CPlayerpc_Stop1945_wrapper(struct CPlayer* _this);
void CPlayerpc_TakeGroundingItem1947_wrapper(struct CPlayer* _this, struct CItemBox* pBox, uint16_t wAddSerial);
void CPlayerpc_TalikCrystalExchange1949_wrapper(struct CPlayer* _this, char byExchangeNum, struct _talik_crystal_exchange_clzo::_list* pList);
void CPlayerpc_ThrowSkillRequest1951_wrapper(struct CPlayer* _this, uint16_t wBulletSerial, struct _CHRID* pidDst, uint16_t* pConsumeSerial);
void CPlayerpc_ThrowStorageItem1953_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem);
void CPlayerpc_ThrowUnitRequest1955_wrapper(struct CPlayer* _this, struct _CHRID* pidDst, uint16_t* pConsumeSerial);
void CPlayerpc_TradeBlock1957_wrapper(struct CPlayer* _this, bool bBlock);
void CPlayerpc_TransShipRenewTicketRequest1959_wrapper(struct CPlayer* _this, uint16_t wTicketItemSerial);
void CPlayerpc_TransformSiegeModeRequest1961_wrapper(struct CPlayer* _this, uint16_t wItemSerial);
void CPlayerpc_TrunkAlterItemSlotRequest1963_wrapper(struct CPlayer* _this, unsigned int dwItemSerial, char byClientSlotIndex, char byStorageIndex);
void CPlayerpc_TrunkChangePasswdRequest1965_wrapper(struct CPlayer* _this, char* pwszPrevPassword, char* pwszChngPassword, char byHintIndex, char* pwszHintAnswer);
char CPlayerpc_TrunkCreateCostIsFreeRequest1967_wrapper(struct CPlayer* _this);
void CPlayerpc_TrunkDownloadRequest1969_wrapper(struct CPlayer* _this, char* pwszPassword);
void CPlayerpc_TrunkEstRequest1971_wrapper(struct CPlayer* _this, char* pwszPassword, char byHintIndex, char* pwszHintAnswer);
void CPlayerpc_TrunkExtendRequest1973_wrapper(struct CPlayer* _this);
void CPlayerpc_TrunkHintAnswerRequest1975_wrapper(struct CPlayer* _this, char* pwszAnswer);
void CPlayerpc_TrunkIoMergeRequest1977_wrapper(struct CPlayer* _this, char byStartStorageIndex, char byTarStorageIndex, uint16_t wStartItemSerial, uint16_t wTarItemSerial, uint16_t wMoveAmount);
void CPlayerpc_TrunkIoMoneyRequest1979_wrapper(struct CPlayer* _this, char byCase, unsigned int dwDalant, unsigned int dwGold);
void CPlayerpc_TrunkIoMoveRequest1981_wrapper(struct CPlayer* _this, char byStartStorageIndex, char byTarStorageIndex, uint16_t wItemSerial, char byClientSlotIndex);
void CPlayerpc_TrunkIoSwapRequest1983_wrapper(struct CPlayer* _this, char byStartStorageIndex, char byTarStorageIndex, uint16_t wStartItemSerial, uint16_t wTarItemSerial);
void CPlayerpc_TrunkPotionDivision1985_wrapper(struct CPlayer* _this, uint16_t wStartSerial, uint16_t wTarSerial, uint16_t wMoveAmount, char byStorageIndex);
void CPlayerpc_TrunkPwHintIndexRequest1987_wrapper(struct CPlayer* _this);
void CPlayerpc_TrunkResDivision1989_wrapper(struct CPlayer* _this, uint16_t wStartSerial, uint16_t wTarSerial, uint16_t wMoveAmount, char byStorageIndex);
void CPlayerpc_UnitBulletFillRequest1991_wrapper(struct CPlayer* _this, char bySlotIndex, uint16_t* pwBulletIndex, int bUseNPCLinkIntem);
void CPlayerpc_UnitBulletReplaceRequest1993_wrapper(struct CPlayer* _this, char bySlotIndex, char byPackIndex, char byBulletPart);
void CPlayerpc_UnitDeliveryRequest1995_wrapper(struct CPlayer* _this, char bySlotIndex, struct CItemStore* pStore, bool bPayFee, float* pfNewPos, int bUseNPCLinkIntem);
void CPlayerpc_UnitFrameBuyRequest1997_wrapper(struct CPlayer* _this, char byFrameCode, int bUseNPCLinkIntem);
void CPlayerpc_UnitFrameRepairRequest1999_wrapper(struct CPlayer* _this, char bySlotIndex, int bUseNPCLinkIntem);
void CPlayerpc_UnitLeaveRequest2001_wrapper(struct CPlayer* _this, float* pfNewPos);
void CPlayerpc_UnitPackFillRequest2003_wrapper(struct CPlayer* _this, char bySlotIndex, char byFillNum, struct _unit_pack_fill_request_clzo::__list* pList, int bUseNPCLinkIntem);
void CPlayerpc_UnitPartTuningRequest2005_wrapper(struct CPlayer* _this, char bySlotIndex, char byTuningNum, struct _tuning_data* pTuningData, int bUseNPCLinkIntem);
void CPlayerpc_UnitReturnRequest2007_wrapper(struct CPlayer* _this);
void CPlayerpc_UnitSellRequest2009_wrapper(struct CPlayer* _this, char bySlotIndex, int bUseNPCLinkIntem);
void CPlayerpc_UnitTakeRequest2011_wrapper(struct CPlayer* _this);
void CPlayerpc_UpdateDataForPostSend2013_wrapper(struct CPlayer* _this);
void CPlayerpc_UpdateDataForTrade2015_wrapper(struct CPlayer* _this, struct CPlayer* pTrader);
void CPlayerpc_UpgradeItem2017_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pposTalik, struct _STORAGE_POS_INDIV* pposToolItem, struct _STORAGE_POS_INDIV* pposUpgItem, char byJewelNum, struct _STORAGE_POS_INDIV* pposUpgJewel);
int CPlayerpc_UseFireCracker2019_wrapper(struct CPlayer* _this, uint16_t wItemSerial);
void CPlayerpc_UsePotionItem2021_wrapper(struct CPlayer* _this, struct CPlayer* pTargetPlayer, struct _STORAGE_POS_INDIV* pItem);
bool CPlayerpc_UseRadarItem2023_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem, uint16_t* pConsumeSerial);
char CPlayerpc_UseRecoverLossExpItem2025_wrapper(struct CPlayer* _this, uint16_t wItemSerial);
char CPlayerpc_UserSoccerBall2027_wrapper(struct CPlayer* _this, uint16_t wItemSerial, uint16_t* wItemIndex);
bool CPlayerpc_WPActiveAttack_Force2029_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int* nDamagedObjNum, struct _force_fld* pForceFld);
bool CPlayerpc_WPActiveAttack_Skill2031_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int* nDamagedObjNum, int* nShotNum, struct _skill_fld* pSkillFld, char byEffectCode, uint16_t wBulletSerial);
void CPlayerpc_WhisperBlock2033_wrapper(struct CPlayer* _this, bool bBlock);
char CPlayerskill_process2035_wrapper(struct CPlayer* _this, int nEffectCode, int nSkillIndex, struct _CHRID* pidDst, uint16_t* pConsumeSerial, int* pnLv);
void CPlayerskill_process_for_aura2037_wrapper(struct CPlayer* _this, int nSkillIndex);
char CPlayerskill_process_for_item2039_wrapper(struct CPlayer* _this, int nSkillIndex, struct _CHRID* pidDst, int* pnLv);
void CPlayerdtor_CPlayer2041_wrapper(struct CPlayer* _this);
| b4fda61d3957f43b7864605f36f3154bc66c188b05b0350456e1bc0fcf082cc0 | 314 |
|
ex | godot | Deps/bullet/src/BulletCollision/CollisionShapes/btBox2dShape.cpp | btBox2dShape::calculateLocalInertia |
void btBox2dShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const
{
btVector3 halfExtents = getHalfExtentsWithMargin();
btScalar lx = btScalar(2.) * (halfExtents.x());
btScalar ly = btScalar(2.) * (halfExtents.y());
btScalar lz = btScalar(2.) * (halfExtents.z());
inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz),
mass / (btScalar(12.0)) * (lx * lx + lz * lz),
mass / (btScalar(12.0)) * (lx * lx + ly * ly));
} |
void btBox2dShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax);
| ee07e5e02d42616414fbe7aa7b5fa2c499bd3d3ce803a95bec45a16e2cb2693b | 463 |
|
kcotugno | Natron | Engine/OfxParamInstance.cpp |
OfxStatus
OfxInteger3DInstance::copyFrom |
OfxStatus
OfxInteger3DInstance::copyFrom(const OFX::Host::Param::Instance &instance,
OfxTime offset,
const OfxRangeD* range)
{
const OfxParamToKnob & other = dynamic_cast<const OfxParamToKnob &>(instance);
return OfxKeyFrame::copyFrom(other.getKnob(), getKnob(), offset, range);
} | bool operator();
PropertyModified_RAII::PropertyModified_RAII(OfxParamToKnob* h);
PropertyModified_RAII::~PropertyModified_RAII();
static boost::shared_ptr<K> resolveRenderKnob(const KnobIPtr& originalKnob);
OfxStringInstancePrivate();
OfxStringInstance::~OfxStringInstance();
OfxCustomInstancePrivate();
OfxCustomInstance::~OfxCustomInstance();
OfxParametricInstance::~OfxParametricInstance();
| d782cbc4c22a931e62a62c87db3397018929fe67076c0cabc38b3aca6ea84084 | 352 |
|
DigitalPulseSoftware | NazaraEngine | src/Nazara/Physics2D/Constraint2D.cpp | RotaryLimitConstraint2D::GetMinAngle | adianAnglef RotaryLimitConstraint2D::GetMinAngle() const
{
return float(cpRotaryLimitJointGetMax(m_constraint));
}
| onstraint2D::Constraint2D(Nz::PhysWorld2D* world, cpConstraint* constraint);
onstraint2D::Constraint2D(Constraint2D&& rhs);
onstraint2D::~Constraint2D();
oid Constraint2D::EnableBodyCollision(bool enable);
igidBody2D& Constraint2D::GetBodyA();
onst RigidBody2D& Constraint2D::GetBodyA();
igidBody2D& Constraint2D::GetBodyB();
onst RigidBody2D& Constraint2D::GetBodyB();
loat Constraint2D::GetErrorBias();
loat Constraint2D::GetLastImpulse();
loat Constraint2D::GetMaxBias();
loat Constraint2D::GetMaxForce();
hysWorld2D& Constraint2D::GetWorld();
onst PhysWorld2D& Constraint2D::GetWorld();
ool Constraint2D::IsBodyCollisionEnabled();
oid Constraint2D::SetErrorBias(float bias);
oid Constraint2D::SetMaxBias(float bias);
oid Constraint2D::SetMaxForce(float force);
onstraint2D& Constraint2D::operator=(Constraint2D && rhs);
ampedSpringConstraint2D::DampedSpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float restLength, float stiffness, float damping);
loat DampedSpringConstraint2D::GetDamping();
ector2f DampedSpringConstraint2D::GetFirstAnchor();
loat DampedSpringConstraint2D::GetRestLength();
ector2f DampedSpringConstraint2D::GetSecondAnchor();
loat DampedSpringConstraint2D::GetStiffness();
oid DampedSpringConstraint2D::SetDamping(float newDamping);
oid DampedSpringConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor);
oid DampedSpringConstraint2D::SetRestLength(float newLength);
oid DampedSpringConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor);
oid DampedSpringConstraint2D::SetStiffness(float newStiffness);
ampedRotarySpringConstraint2D::DampedRotarySpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& restAngle, float stiffness, float damping);
loat DampedRotarySpringConstraint2D::GetDamping();
adianAnglef DampedRotarySpringConstraint2D::GetRestAngle();
loat DampedRotarySpringConstraint2D::GetStiffness();
oid DampedRotarySpringConstraint2D::SetDamping(float newDamping);
oid DampedRotarySpringConstraint2D::SetRestAngle(const RadianAnglef& newAngle);
oid DampedRotarySpringConstraint2D::SetStiffness(float newStiffness);
earConstraint2D::GearConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratio);
loat GearConstraint2D::GetPhase();
loat GearConstraint2D::GetRatio();
oid GearConstraint2D::SetPhase(float phase);
oid GearConstraint2D::SetRatio(float ratio);
otorConstraint2D::MotorConstraint2D(RigidBody2D& first, RigidBody2D& second, float rate);
loat MotorConstraint2D::GetRate();
oid MotorConstraint2D::SetRate(float rate);
inConstraint2D::PinConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor);
loat PinConstraint2D::GetDistance();
ector2f PinConstraint2D::GetFirstAnchor();
ector2f PinConstraint2D::GetSecondAnchor();
oid PinConstraint2D::SetDistance(float newDistance);
oid PinConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor);
oid PinConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor);
ivotConstraint2D::PivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& anchor);
ivotConstraint2D::PivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor);
ector2f PivotConstraint2D::GetFirstAnchor();
ector2f PivotConstraint2D::GetSecondAnchor();
oid PivotConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor);
oid PivotConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor);
atchetConstraint2D::RatchetConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratchet);
adianAnglef RatchetConstraint2D::GetAngle();
loat RatchetConstraint2D::GetPhase();
loat RatchetConstraint2D::GetRatchet();
oid RatchetConstraint2D::SetAngle(const RadianAnglef& angle);
oid RatchetConstraint2D::SetPhase(float phase);
oid RatchetConstraint2D::SetRatchet(float ratchet);
otaryLimitConstraint2D::RotaryLimitConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& minAngle, const RadianAnglef& maxAngle);
adianAnglef RotaryLimitConstraint2D::GetMaxAngle();
oid RotaryLimitConstraint2D::SetMaxAngle(const RadianAnglef& maxAngle);
oid RotaryLimitConstraint2D::SetMinAngle(const RadianAnglef& minAngle);
lideConstraint2D::SlideConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float min, float max);
ector2f SlideConstraint2D::GetFirstAnchor();
loat SlideConstraint2D::GetMaxDistance();
loat SlideConstraint2D::GetMinDistance();
ector2f SlideConstraint2D::GetSecondAnchor();
oid SlideConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor);
oid SlideConstraint2D::SetMaxDistance(float newMaxDistance);
oid SlideConstraint2D::SetMinDistance(float newMinDistance);
oid SlideConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor);
| dbf3746e177526b69724fe9fd4948314c558e40914db0bfae0a8a9b032a98f1c | 120 |
|
millerp | IGC.GameServer | GameServer/Bag.cpp |
CBag::CBag |
CBag::CBag() {
this->InitBag();
} |
CBag::~CBag();
bool CBag::LoadBag(const char *lpFileName);
void CBag::InitBag();
int CBag::GetDropSection(int aIndex, BAG_SECTION_DROP &pRetDrop);
int CBag::GetItemsSection(BAG_SECTION_DROP &pDropSec, BAG_SECTION_ITEMS &pRetItems);
int CBag::GetItem(BAG_SECTION_ITEMS &pItemsSec, BAG_ITEM &pRetItem);
int CBag::GetReadyItemToUse(int aIndex, CItem &pItem, time_t &DurationItem);
int CBag::GetItemLevel(int MinLevel, int MaxLevel);
void CBag::MakeBagEffectUse(int aIndex, int iMonsterIndex);
void CBag::AddCoin(int aIndex);
void CBag::DropSummonItem(int aIndex);
| f98d81064e9785511198526e85037b0bd24529638acaa11b5a9bc83d53bb19c8 | 38 |
|
yanesroann | yanesroann | tetris/tetrisboard.cpp | Tetrisboard::getEndgame |
bool Tetrisboard::getEndgame()
{ return endgame; } |
Tetrisboard::Tetrisboard();
int Tetrisboard::getx();
int Tetrisboard::gety();
int Tetrisboard::getRed();
int Tetrisboard::getGreen();
int Tetrisboard::getBlue();
int Tetrisboard::getShape();
int Tetrisboard::getOrientation();
void Tetrisboard::setx(int x);
void Tetrisboard::sety(int y);
void Tetrisboard::setColor(int r, int g, int b);
void Tetrisboard::setShape(int s);
void Tetrisboard::setOrientation(int o);
void Tetrisboard::setEndgame(bool truthvalue);
void Tetrisboard::initialize();
void Tetrisboard::drawLines();
void Tetrisboard::displayArray();
void Tetrisboard::addblock(int x, int y);
void Tetrisboard::removeblock(int x, int y);
void Tetrisboard::fall();
void Tetrisboard::moveLeft();
void Tetrisboard::moveRight();
bool Tetrisboard::openRotate();
void Tetrisboard::rotate();
bool Tetrisboard::checkbelow();
void Tetrisboard::clearLine();
| 5459133a463e59f0003fe3934834cc840d91acda44ddcaa9ea20cebc850efbc9 | 53 |
|
Code0100Food | 3DEngine | MonoScripting/MonoScripting/test.cpp | SetFieldValue | void SetFieldValue(MonoObject * script, MonoClassField * field, void * input_value)
{
mono_field_set_value(script, field, input_value);
} | const char* MonoScripting::GetDLLPath();
const char* MonoScripting::GetLastError();
bool MonoScripting::InitMono();
bool MonoScripting::CleanUpMono();
MonoDomain * LoadAppDomain();
void UnLoadAppDomain();
bool MonoScripting::CompileFile(const char* input_file, const char* output_file);
MonoAssemblyName* MonoScripting::LoadScriptAssembly(const char* assembly_path);
bool MonoScripting::UnLoadScriptAssembly(MonoAssemblyName * asm_);
MonoObject* MonoScripting::CreateMonoObject(MonoAssemblyName* assembly, const char* class_name, const char* name_space);
MonoImage * LoadMonoImage(MonoAssemblyName * asm_);
bool MonoScripting::ExecuteMethod(MonoObject* script, const char* method_name);
void AddMethodInternalCall(const char * cs_path, const void * method);
const char* MonoStringToConstChar(MonoString* string);
const char* MonoScripting::GetFieldsNameAndType(MonoObject* script, void** iterator);
unsigned int MonoScripting::GetFieldValue(MonoObject* script, const char* field_name, void** output_value);
MonoClassField * GetFieldValue(MonoImage * image, const char * namespace_, const char * class_name, const char * field_name);
bool MonoScripting::SetFieldValue(MonoObject* script, const char* field_name, void* input_value);
int main(int argc, char *argv[]);
| a5c0b9766422cf6aab3da44045e710b3b2545d2ba3f47a6da6b2dcf2821e588d | 142 |
|
Chuck5ta | Game-server-emulator | src/game/SpellAuras.cpp | Aura::HandleModTaunt |
void Aura::HandleModTaunt(bool apply, bool Real)
{
if (!Real)
return;
Unit* target = GetTarget();
if (!target->IsAlive() || !target->CanHaveThreatList())
return;
Unit* caster = GetCaster();
if (!caster || !caster->IsAlive())
return;
if (apply)
target->TauntApply(caster);
else
{
target->TauntFadeOut(caster);
}
} |
Aura::Aura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster, Item* castItem);
Aura::~Aura();
AreaAura::~AreaAura();
PersistentAreaAura::~PersistentAreaAura();
SingleEnemyTargetAura::~SingleEnemyTargetAura();
Unit* SingleEnemyTargetAura::GetTriggerTarget();
Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster, Item* castItem);
SpellAuraHolder* CreateSpellAuraHolder(SpellEntry const* spellproto, Unit* target, WorldObject* caster, Item* castItem);
void Aura::SetModifier(AuraType t, int32 a, uint32 pt, int32 miscValue);
void Aura::Update(uint32 diff);
void AreaAura::Update(uint32 diff);
void PersistentAreaAura::Update(uint32 diff);
void Aura::ApplyModifier(bool apply, bool Real);
bool Aura::isAffectedOnSpell(SpellEntry const* spell);
bool Aura::CanProcFrom(SpellEntry const* spell, uint32 /*procFlag*/, uint32 EventProcEx, uint32 procEx, bool active, bool useClassMask);
void Aura::ReapplyAffectedPassiveAuras(Unit* target, bool owner_mode);
void Aura::ReapplyAffectedPassiveAuras();
void Aura::HandleAddModifier(bool apply, bool Real);
void Aura::TriggerSpell();
void Aura::TriggerSpellWithValue();
void Aura::HandleAuraDummy(bool apply, bool Real);
void Aura::HandleAuraMounted(bool apply, bool Real);
void Aura::HandleAuraWaterWalk(bool apply, bool Real);
void Aura::HandleAuraFeatherFall(bool apply, bool Real);
void Aura::HandleAuraHover(bool apply, bool Real);
void Aura::HandleWaterBreathing(bool /*apply*/, bool /*Real*/);
void Aura::HandleAuraModShapeshift(bool apply, bool Real);
void Aura::HandleAuraTransform(bool apply, bool Real);
void Aura::HandleForceReaction(bool apply, bool Real);
void Aura::HandleAuraModSkill(bool apply, bool /*Real*/);
void Aura::HandleChannelDeathItem(bool apply, bool Real);
void Aura::HandleBindSight(bool apply, bool /*Real*/);
void Aura::HandleFarSight(bool apply, bool /*Real*/);
void Aura::HandleAuraTrackCreatures(bool apply, bool /*Real*/);
void Aura::HandleAuraTrackResources(bool apply, bool /*Real*/);
void Aura::HandleAuraTrackStealthed(bool apply, bool /*Real*/);
void Aura::HandleAuraModScale(bool apply, bool /*Real*/);
void Aura::HandleModPossess(bool apply, bool Real);
void Aura::HandleModPossessPet(bool apply, bool Real);
void Aura::HandleAuraModPetTalentsPoints(bool /*Apply*/, bool Real);
void Aura::HandleModCharm(bool apply, bool Real);
void Aura::HandleModConfuse(bool apply, bool Real);
void Aura::HandleModFear(bool apply, bool Real);
void Aura::HandleFeignDeath(bool apply, bool Real);
void Aura::HandleAuraModDisarm(bool apply, bool Real);
void Aura::HandleAuraModStun(bool apply, bool Real);
void Aura::HandleModStealth(bool apply, bool Real);
void Aura::HandleInvisibility(bool apply, bool Real);
void Aura::HandleInvisibilityDetect(bool apply, bool Real);
void Aura::HandleDetectAmore(bool apply, bool /*real*/);
void Aura::HandleAuraModRoot(bool apply, bool Real);
void Aura::HandleAuraModSilence(bool apply, bool Real);
void Aura::HandleModThreat(bool apply, bool Real);
void Aura::HandleAuraModTotalThreat(bool apply, bool Real);
void Aura::HandleAuraFakeInebriation(bool apply, bool Real);
void Aura::HandleAuraModIncreaseSpeed(bool /*apply*/, bool Real);
void Aura::HandleAuraModIncreaseMountedSpeed(bool apply, bool Real);
void Aura::HandleAuraModIncreaseFlightSpeed(bool apply, bool Real);
void Aura::HandleAuraModIncreaseSwimSpeed(bool /*apply*/, bool Real);
void Aura::HandleAuraModDecreaseSpeed(bool apply, bool Real);
void Aura::HandleAuraModUseNormalSpeed(bool /*apply*/, bool Real);
void Aura::HandleModMechanicImmunity(bool apply, bool /*Real*/);
void Aura::HandleModMechanicImmunityMask(bool apply, bool /*Real*/);
void Aura::HandleAuraModEffectImmunity(bool apply, bool /*Real*/);
void Aura::HandleAuraModStateImmunity(bool apply, bool Real);
void Aura::HandleAuraModSchoolImmunity(bool apply, bool Real);
void Aura::HandleAuraModDmgImmunity(bool apply, bool /*Real*/);
void Aura::HandleAuraModDispelImmunity(bool apply, bool Real);
void Aura::HandleAuraProcTriggerSpell(bool apply, bool Real);
void Aura::HandleAuraModStalked(bool apply, bool /*Real*/);
void Aura::HandlePeriodicTriggerSpell(bool apply, bool /*Real*/);
void Aura::HandlePeriodicTriggerSpellWithValue(bool apply, bool /*Real*/);
void Aura::HandlePeriodicEnergize(bool apply, bool Real);
void Aura::HandleAuraPowerBurn(bool apply, bool /*Real*/);
void Aura::HandleAuraPeriodicDummy(bool apply, bool Real);
void Aura::HandlePeriodicHeal(bool apply, bool /*Real*/);
void Aura::HandleDamagePercentTaken(bool apply, bool Real);
void Aura::HandlePeriodicDamage(bool apply, bool Real);
void Aura::HandlePeriodicDamagePCT(bool apply, bool /*Real*/);
void Aura::HandlePeriodicLeech(bool apply, bool /*Real*/);
void Aura::HandlePeriodicManaLeech(bool apply, bool /*Real*/);
void Aura::HandlePeriodicHealthFunnel(bool apply, bool /*Real*/);
void Aura::HandleAuraModResistanceExclusive(bool apply, bool /*Real*/);
void Aura::HandleAuraModResistance(bool apply, bool /*Real*/);
void Aura::HandleAuraModBaseResistancePCT(bool apply, bool /*Real*/);
void Aura::HandleModResistancePercent(bool apply, bool /*Real*/);
void Aura::HandleModBaseResistance(bool apply, bool /*Real*/);
void Aura::HandleAuraModStat(bool apply, bool /*Real*/);
void Aura::HandleModPercentStat(bool apply, bool /*Real*/);
void Aura::HandleModSpellDamagePercentFromStat(bool /*apply*/, bool /*Real*/);
void Aura::HandleModSpellHealingPercentFromStat(bool /*apply*/, bool /*Real*/);
void Aura::HandleAuraModDispelResist(bool apply, bool Real);
void Aura::HandleModSpellDamagePercentFromAttackPower(bool /*apply*/, bool /*Real*/);
void Aura::HandleModSpellHealingPercentFromAttackPower(bool /*apply*/, bool /*Real*/);
void Aura::HandleModHealingDone(bool /*apply*/, bool /*Real*/);
void Aura::HandleModTotalPercentStat(bool apply, bool /*Real*/);
void Aura::HandleAuraModResistenceOfStatPercent(bool /*apply*/, bool /*Real*/);
void Aura::HandleAuraModTotalHealthPercentRegen(bool apply, bool /*Real*/);
void Aura::HandleAuraModTotalManaPercentRegen(bool apply, bool /*Real*/);
void Aura::HandleModRegen(bool apply, bool /*Real*/);
void Aura::HandleModPowerRegen(bool apply, bool Real);
void Aura::HandleModPowerRegenPCT(bool /*apply*/, bool Real);
void Aura::HandleModManaRegen(bool /*apply*/, bool Real);
void Aura::HandleComprehendLanguage(bool apply, bool /*Real*/);
void Aura::HandleAuraModIncreaseHealth(bool apply, bool Real);
void Aura::HandleAuraModIncreaseMaxHealth(bool apply, bool /*Real*/);
void Aura::HandleAuraModIncreaseEnergy(bool apply, bool Real);
void Aura::HandleAuraModIncreaseEnergyPercent(bool apply, bool /*Real*/);
void Aura::HandleAuraModIncreaseHealthPercent(bool apply, bool /*Real*/);
void Aura::HandleAuraIncreaseBaseHealthPercent(bool apply, bool /*Real*/);
void Aura::HandleAuraModParryPercent(bool /*apply*/, bool /*Real*/);
void Aura::HandleAuraModDodgePercent(bool /*apply*/, bool /*Real*/);
void Aura::HandleAuraModBlockChancePercent(bool /*apply*/, bool /*Real*/);
void Aura::HandleAuraModRegenInterrupt(bool /*apply*/, bool Real);
void Aura::HandleAuraModCritPercent(bool apply, bool Real);
void Aura::HandleModHitChance(bool apply, bool /*Real*/);
void Aura::HandleModSpellHitChance(bool apply, bool /*Real*/);
void Aura::HandleModSpellCritChance(bool apply, bool Real);
void Aura::HandleModSpellCritChanceShool(bool /*apply*/, bool Real);
void Aura::HandleModCastingSpeed(bool apply, bool /*Real*/);
void Aura::HandleModMeleeRangedSpeedPct(bool apply, bool /*Real*/);
void Aura::HandleModCombatSpeedPct(bool apply, bool /*Real*/);
void Aura::HandleModAttackSpeed(bool apply, bool /*Real*/);
void Aura::HandleModMeleeSpeedPct(bool apply, bool /*Real*/);
void Aura::HandleAuraModRangedHaste(bool apply, bool /*Real*/);
void Aura::HandleRangedAmmoHaste(bool apply, bool /*Real*/);
void Aura::HandleAuraModAttackPower(bool apply, bool /*Real*/);
void Aura::HandleAuraModRangedAttackPower(bool apply, bool /*Real*/);
void Aura::HandleAuraModAttackPowerPercent(bool apply, bool /*Real*/);
void Aura::HandleAuraModRangedAttackPowerPercent(bool apply, bool /*Real*/);
void Aura::HandleAuraModAttackPowerOfArmor(bool /*apply*/, bool Real);
void Aura::HandleModDamageDone(bool apply, bool Real);
void Aura::HandleModDamagePercentDone(bool apply, bool Real);
void Aura::HandleModOffhandDamagePercent(bool apply, bool Real);
void Aura::HandleModPowerCostPCT(bool apply, bool Real);
void Aura::HandleModPowerCost(bool apply, bool Real);
void Aura::HandleNoReagentUseAura(bool /*Apply*/, bool Real);
void Aura::HandleShapeshiftBoosts(bool apply);
void Aura::HandleAuraEmpathy(bool apply, bool /*Real*/);
void Aura::HandleAuraUntrackable(bool apply, bool /*Real*/);
void Aura::HandleAuraModPacify(bool apply, bool /*Real*/);
void Aura::HandleAuraModPacifyAndSilence(bool apply, bool Real);
void Aura::HandleAuraGhost(bool apply, bool /*Real*/);
void Aura::HandleAuraAllowFlight(bool apply, bool Real);
void Aura::HandleModRating(bool apply, bool Real);
void Aura::HandleModRatingFromStat(bool apply, bool Real);
void Aura::HandleForceMoveForward(bool apply, bool Real);
void Aura::HandleAuraModExpertise(bool /*apply*/, bool /*Real*/);
void Aura::HandleModTargetResistance(bool apply, bool Real);
void Aura::HandleModShieldBlockDamage(bool apply, bool /*Real*/);
void Aura::HandleAuraRetainComboPoints(bool apply, bool Real);
void Aura::HandleModUnattackable(bool Apply, bool Real);
void Aura::HandleSpiritOfRedemption(bool apply, bool Real);
void Aura::HandleSchoolAbsorb(bool apply, bool Real);
void Aura::PeriodicTick();
void Aura::PeriodicDummyTick();
void Aura::HandlePreventFleeing(bool apply, bool Real);
void Aura::HandleManaShield(bool apply, bool Real);
void Aura::HandleArenaPreparation(bool apply, bool Real);
void Aura::HandleAuraControlVehicle(bool apply, bool Real);
void Aura::HandleAuraAddMechanicAbilities(bool apply, bool Real);
void Aura::HandleAuraOpenStable(bool apply, bool Real);
void Aura::HandleAuraMirrorImage(bool apply, bool Real);
void Aura::HandleAuraConvertRune(bool apply, bool Real);
void Aura::HandlePhase(bool apply, bool Real);
void Aura::HandleAuraSafeFall(bool Apply, bool Real);
bool Aura::IsCritFromAbilityAura(Unit* caster, uint32& damage);
void Aura::HandleAuraModAllCritChance(bool apply, bool Real);
void Aura::HandleAuraStopNaturalManaRegen(bool apply, bool Real);
void Aura::HandleAuraSetVehicleId(bool apply, bool Real);
void Aura::HandleAuraMastery(bool apply, bool Real);
void Aura::HandleAuraModBlockCritChance(bool apply, bool Real);
bool Aura::IsLastAuraOnHolder();
bool Aura::HasMechanic(uint32 mechanic);
SpellAuraHolder::SpellAuraHolder(SpellEntry const* spellproto, Unit* target, WorldObject* caster, Item* castItem);
void SpellAuraHolder::AddAura(Aura* aura, SpellEffectIndex index);
void SpellAuraHolder::RemoveAura(SpellEffectIndex index);
void SpellAuraHolder::ApplyAuraModifiers(bool apply, bool real);
void SpellAuraHolder::_AddSpellAuraHolder();
void SpellAuraHolder::_RemoveSpellAuraHolder();
void SpellAuraHolder::CleanupTriggeredSpells();
bool SpellAuraHolder::ModStackAmount(int32 num);
void SpellAuraHolder::SetStackAmount(uint32 stackAmount);
Unit* SpellAuraHolder::GetCaster();
bool SpellAuraHolder::IsWeaponBuffCoexistableWith(SpellAuraHolder const* ref);
bool SpellAuraHolder::IsNeedVisibleSlot(Unit const* caster);
void SpellAuraHolder::BuildUpdatePacket(WorldPacket& data);
void SpellAuraHolder::SendAuraUpdate(bool remove);
void SpellAuraHolder::HandleSpellSpecificBoosts(bool apply);
SpellAuraHolder::~SpellAuraHolder();
void SpellAuraHolder::Update(uint32 diff);
void SpellAuraHolder::RefreshHolder();
void SpellAuraHolder::SetAuraMaxDuration(int32 duration);
bool SpellAuraHolder::HasMechanic(uint32 mechanic);
bool SpellAuraHolder::HasMechanicMask(uint32 mechanicMask);
bool SpellAuraHolder::IsPersistent();
bool SpellAuraHolder::IsAreaAura();
bool SpellAuraHolder::IsPositive();
bool SpellAuraHolder::IsEmptyHolder();
void SpellAuraHolder::UnregisterAndCleanupTrackedAuras();
void Aura::HandleModIncreaseSpellPowerPct(bool apply, bool Real);
void Aura::HandleOverrideSpellPowerByAp(bool apply, bool Real);
| e1a50881c9664f921cf3b3a8b1c7d335c81506afc1546fdc76964b2f03abddda | 410 |
|
pixelpicosean | my-godot-2.1 | servers/visual/visual_server_raster.cpp | VisualServerRaster::camera_create |
RID VisualServerRaster::camera_create() {
Camera *camera = memnew(Camera);
return camera_owner.make_rid(camera);
} |
RID VisualServerRaster::texture_create();
void VisualServerRaster::texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags);
void VisualServerRaster::texture_set_flags(RID p_texture, uint32_t p_flags);
void VisualServerRaster::texture_set_data(RID p_texture, const Image &p_image, CubeMapSide p_cube_side);
Image VisualServerRaster::texture_get_data(RID p_texture, CubeMapSide p_cube_side);
uint32_t VisualServerRaster::texture_get_flags(RID p_texture);
Image::Format VisualServerRaster::texture_get_format(RID p_texture);
uint32_t VisualServerRaster::texture_get_width(RID p_texture);
uint32_t VisualServerRaster::texture_get_height(RID p_texture);
void VisualServerRaster::texture_set_size_override(RID p_texture, int p_width, int p_height);
bool VisualServerRaster::texture_can_stream(RID p_texture);
void VisualServerRaster::texture_set_reload_hook(RID p_texture, ObjectID p_owner, const StringName &p_function);
void VisualServerRaster::texture_set_path(RID p_texture, const String &p_path);
String VisualServerRaster::texture_get_path(RID p_texture);
void VisualServerRaster::texture_debug_usage(List<TextureInfo> *r_info);
void VisualServerRaster::texture_set_shrink_all_x2_on_set_data(bool p_enable);
RID VisualServerRaster::shader_create(ShaderMode p_mode);
void VisualServerRaster::shader_set_mode(RID p_shader, ShaderMode p_mode);
VisualServer::ShaderMode VisualServerRaster::shader_get_mode(RID p_shader);
void VisualServerRaster::shader_set_code(RID p_shader, const String &p_vertex, const String &p_fragment, const String &p_light, int p_vertex_ofs, int p_fragment_ofs, int p_light_ofs);
String VisualServerRaster::shader_get_vertex_code(RID p_shader);
String VisualServerRaster::shader_get_fragment_code(RID p_shader);
String VisualServerRaster::shader_get_light_code(RID p_shader);
void VisualServerRaster::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list);
void VisualServerRaster::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture);
RID VisualServerRaster::shader_get_default_texture_param(RID p_shader, const StringName &p_name);
RID VisualServerRaster::material_create();
void VisualServerRaster::material_set_shader(RID p_material, RID p_shader);
RID VisualServerRaster::material_get_shader(RID p_material);
void VisualServerRaster::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value);
Variant VisualServerRaster::material_get_param(RID p_material, const StringName &p_param);
void VisualServerRaster::material_set_flag(RID p_material, MaterialFlag p_flag, bool p_enabled);
void VisualServerRaster::material_set_depth_draw_mode(RID p_material, MaterialDepthDrawMode p_mode);
VS::MaterialDepthDrawMode VisualServerRaster::material_get_depth_draw_mode(RID p_material);
bool VisualServerRaster::material_get_flag(RID p_material, MaterialFlag p_flag);
void VisualServerRaster::material_set_blend_mode(RID p_material, MaterialBlendMode p_mode);
VS::MaterialBlendMode VisualServerRaster::material_get_blend_mode(RID p_material);
void VisualServerRaster::material_set_line_width(RID p_material, float p_line_width);
float VisualServerRaster::material_get_line_width(RID p_material);
RID VisualServerRaster::fixed_material_create();
void VisualServerRaster::fixed_material_set_flag(RID p_material, FixedMaterialFlags p_flag, bool p_enabled);
bool VisualServerRaster::fixed_material_get_flag(RID p_material, FixedMaterialFlags p_flag);
void VisualServerRaster::fixed_material_set_param(RID p_material, FixedMaterialParam p_parameter, const Variant &p_value);
Variant VisualServerRaster::fixed_material_get_param(RID p_material, FixedMaterialParam p_parameter);
void VisualServerRaster::fixed_material_set_texture(RID p_material, FixedMaterialParam p_parameter, RID p_texture);
RID VisualServerRaster::fixed_material_get_texture(RID p_material, FixedMaterialParam p_parameter);
void VisualServerRaster::fixed_material_set_texcoord_mode(RID p_material, FixedMaterialParam p_parameter, FixedMaterialTexCoordMode p_mode);
VS::FixedMaterialTexCoordMode VisualServerRaster::fixed_material_get_texcoord_mode(RID p_material, FixedMaterialParam p_parameter);
void VisualServerRaster::fixed_material_set_point_size(RID p_material, float p_size);
float VisualServerRaster::fixed_material_get_point_size(RID p_material);
void VisualServerRaster::fixed_material_set_uv_transform(RID p_material, const Transform &p_transform);
Transform VisualServerRaster::fixed_material_get_uv_transform(RID p_material);
void VisualServerRaster::fixed_material_set_light_shader(RID p_material, FixedMaterialLightShader p_shader);
VisualServerRaster::FixedMaterialLightShader VisualServerRaster::fixed_material_get_light_shader(RID p_material);
RID VisualServerRaster::mesh_create();
void VisualServerRaster::mesh_set_morph_target_count(RID p_mesh, int p_amount);
int VisualServerRaster::mesh_get_morph_target_count(RID p_mesh);
void VisualServerRaster::mesh_set_morph_target_mode(RID p_mesh, MorphTargetMode p_mode);
VisualServer::MorphTargetMode VisualServerRaster::mesh_get_morph_target_mode(RID p_mesh);
void VisualServerRaster::mesh_add_custom_surface(RID p_mesh, const Variant &p_dat);
void VisualServerRaster::mesh_add_surface(RID p_mesh, PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes, bool p_alpha_sort);
Array VisualServerRaster::mesh_get_surface_arrays(RID p_mesh, int p_surface);
Array VisualServerRaster::mesh_get_surface_morph_arrays(RID p_mesh, int p_surface);
void VisualServerRaster::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material, bool p_owned);
RID VisualServerRaster::mesh_surface_get_material(RID p_mesh, int p_surface);
int VisualServerRaster::mesh_surface_get_array_len(RID p_mesh, int p_surface);
int VisualServerRaster::mesh_surface_get_array_index_len(RID p_mesh, int p_surface);
uint32_t VisualServerRaster::mesh_surface_get_format(RID p_mesh, int p_surface);
VisualServer::PrimitiveType VisualServerRaster::mesh_surface_get_primitive_type(RID p_mesh, int p_surface);
void VisualServerRaster::mesh_remove_surface(RID p_mesh, int p_surface);
int VisualServerRaster::mesh_get_surface_count(RID p_mesh);
void VisualServerRaster::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb);
AABB VisualServerRaster::mesh_get_custom_aabb(RID p_mesh);
void VisualServerRaster::mesh_clear(RID p_mesh);
RID VisualServerRaster::multimesh_create();
void VisualServerRaster::multimesh_set_instance_count(RID p_multimesh, int p_count);
int VisualServerRaster::multimesh_get_instance_count(RID p_multimesh);
void VisualServerRaster::multimesh_set_mesh(RID p_multimesh, RID p_mesh);
void VisualServerRaster::multimesh_set_aabb(RID p_multimesh, const AABB &p_aabb);
void VisualServerRaster::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform);
void VisualServerRaster::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color);
RID VisualServerRaster::multimesh_get_mesh(RID p_multimesh);
AABB VisualServerRaster::multimesh_get_aabb(RID p_multimesh, const AABB &p_aabb);
Transform VisualServerRaster::multimesh_instance_get_transform(RID p_multimesh, int p_index);
Color VisualServerRaster::multimesh_instance_get_color(RID p_multimesh, int p_index);
void VisualServerRaster::multimesh_set_visible_instances(RID p_multimesh, int p_visible);
int VisualServerRaster::multimesh_get_visible_instances(RID p_multimesh);
RID VisualServerRaster::immediate_create();
void VisualServerRaster::immediate_begin(RID p_immediate, PrimitiveType p_primitive, RID p_texture);
void VisualServerRaster::immediate_vertex(RID p_immediate, const Vector3 &p_vertex);
void VisualServerRaster::immediate_normal(RID p_immediate, const Vector3 &p_normal);
void VisualServerRaster::immediate_tangent(RID p_immediate, const Plane &p_tangent);
void VisualServerRaster::immediate_color(RID p_immediate, const Color &p_color);
void VisualServerRaster::immediate_uv(RID p_immediate, const Vector2 &p_uv);
void VisualServerRaster::immediate_uv2(RID p_immediate, const Vector2 &p_uv2);
void VisualServerRaster::immediate_end(RID p_immediate);
void VisualServerRaster::immediate_clear(RID p_immediate);
void VisualServerRaster::immediate_set_material(RID p_immediate, RID p_material);
RID VisualServerRaster::immediate_get_material(RID p_immediate);
RID VisualServerRaster::particles_create();
void VisualServerRaster::particles_set_amount(RID p_particles, int p_amount);
int VisualServerRaster::particles_get_amount(RID p_particles);
void VisualServerRaster::particles_set_emitting(RID p_particles, bool p_emitting);
bool VisualServerRaster::particles_is_emitting(RID p_particles);
void VisualServerRaster::particles_set_visibility_aabb(RID p_particles, const AABB &p_visibility);
AABB VisualServerRaster::particles_get_visibility_aabb(RID p_particles);
void VisualServerRaster::particles_set_emission_half_extents(RID p_particles, const Vector3 &p_half_extents);
Vector3 VisualServerRaster::particles_get_emission_half_extents(RID p_particles);
void VisualServerRaster::particles_set_emission_base_velocity(RID p_particles, const Vector3 &p_base_velocity);
Vector3 VisualServerRaster::particles_get_emission_base_velocity(RID p_particles);
void VisualServerRaster::particles_set_emission_points(RID p_particles, const DVector<Vector3> &p_points);
DVector<Vector3> VisualServerRaster::particles_get_emission_points(RID p_particles);
void VisualServerRaster::particles_set_gravity_normal(RID p_particles, const Vector3 &p_normal);
Vector3 VisualServerRaster::particles_get_gravity_normal(RID p_particles);
void VisualServerRaster::particles_set_variable(RID p_particles, ParticleVariable p_variable, float p_value);
float VisualServerRaster::particles_get_variable(RID p_particles, ParticleVariable p_variable);
void VisualServerRaster::particles_set_randomness(RID p_particles, ParticleVariable p_variable, float p_randomness);
float VisualServerRaster::particles_get_randomness(RID p_particles, ParticleVariable p_variable);
void VisualServerRaster::particles_set_color_phases(RID p_particles, int p_phases);
int VisualServerRaster::particles_get_color_phases(RID p_particles);
void VisualServerRaster::particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos);
float VisualServerRaster::particles_get_color_phase_pos(RID p_particles, int p_phase);
void VisualServerRaster::particles_set_attractors(RID p_particles, int p_attractors);
int VisualServerRaster::particles_get_attractors(RID p_particles);
void VisualServerRaster::particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3 &p_pos);
Vector3 VisualServerRaster::particles_get_attractor_pos(RID p_particles, int p_attractor);
void VisualServerRaster::particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force);
float VisualServerRaster::particles_get_attractor_strength(RID p_particles, int p_attractor);
void VisualServerRaster::particles_set_color_phase_color(RID p_particles, int p_phase, const Color &p_color);
Color VisualServerRaster::particles_get_color_phase_color(RID p_particles, int p_phase);
void VisualServerRaster::particles_set_material(RID p_particles, RID p_material, bool p_owned);
RID VisualServerRaster::particles_get_material(RID p_particles);
void VisualServerRaster::particles_set_height_from_velocity(RID p_particles, bool p_enable);
bool VisualServerRaster::particles_has_height_from_velocity(RID p_particles);
void VisualServerRaster::particles_set_use_local_coordinates(RID p_particles, bool p_enable);
bool VisualServerRaster::particles_is_using_local_coordinates(RID p_particles);
RID VisualServerRaster::light_create(LightType p_type);
VisualServer::LightType VisualServerRaster::light_get_type(RID p_light);
void VisualServerRaster::light_set_color(RID p_light, LightColor p_type, const Color &p_color);
Color VisualServerRaster::light_get_color(RID p_light, LightColor p_type);
void VisualServerRaster::light_set_shadow(RID p_light, bool p_enabled);
bool VisualServerRaster::light_has_shadow(RID p_light);
void VisualServerRaster::light_set_volumetric(RID p_light, bool p_enabled);
bool VisualServerRaster::light_is_volumetric(RID p_light);
void VisualServerRaster::light_set_projector(RID p_light, RID p_texture);
RID VisualServerRaster::light_get_projector(RID p_light);
void VisualServerRaster::light_set_param(RID p_light, LightParam p_var, float p_value);
float VisualServerRaster::light_get_param(RID p_light, LightParam p_var);
void VisualServerRaster::light_set_operator(RID p_light, LightOp p_op);
VisualServerRaster::LightOp VisualServerRaster::light_get_operator(RID p_light);
void VisualServerRaster::light_omni_set_shadow_mode(RID p_light, LightOmniShadowMode p_mode);
VisualServerRaster::LightOmniShadowMode VisualServerRaster::light_omni_get_shadow_mode(RID p_light);
void VisualServerRaster::light_directional_set_shadow_mode(RID p_light, LightDirectionalShadowMode p_mode);
VS::LightDirectionalShadowMode VisualServerRaster::light_directional_get_shadow_mode(RID p_light);
void VisualServerRaster::light_directional_set_shadow_param(RID p_light, LightDirectionalShadowParam p_param, float p_value);
float VisualServerRaster::light_directional_get_shadow_param(RID p_light, LightDirectionalShadowParam p_param);
RID VisualServerRaster::skeleton_create();
void VisualServerRaster::skeleton_resize(RID p_skeleton, int p_bones);
int VisualServerRaster::skeleton_get_bone_count(RID p_skeleton);
void VisualServerRaster::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform);
Transform VisualServerRaster::skeleton_bone_get_transform(RID p_skeleton, int p_bone);
RID VisualServerRaster::room_create();
void VisualServerRaster::room_set_bounds(RID p_room, const BSP_Tree &p_bounds);
BSP_Tree VisualServerRaster::room_get_bounds(RID p_room);
RID VisualServerRaster::portal_create();
void VisualServerRaster::portal_set_shape(RID p_portal, const Vector<Point2> &p_shape);
Vector<Point2> VisualServerRaster::portal_get_shape(RID p_portal);
void VisualServerRaster::portal_set_enabled(RID p_portal, bool p_enabled);
bool VisualServerRaster::portal_is_enabled(RID p_portal);
void VisualServerRaster::portal_set_disable_distance(RID p_portal, float p_distance);
float VisualServerRaster::portal_get_disable_distance(RID p_portal);
void VisualServerRaster::portal_set_disabled_color(RID p_portal, const Color &p_color);
Color VisualServerRaster::portal_get_disabled_color(RID p_portal);
void VisualServerRaster::portal_set_connect_range(RID p_portal, float p_range);
float VisualServerRaster::portal_get_connect_range(RID p_portal);
RID VisualServerRaster::baked_light_create();
void VisualServerRaster::baked_light_set_mode(RID p_baked_light, BakedLightMode p_mode);
VisualServer::BakedLightMode VisualServerRaster::baked_light_get_mode(RID p_baked_light);
void VisualServerRaster::baked_light_set_lightmap_multiplier(RID p_baked_light, float p_multiplier);
float VisualServerRaster::baked_light_get_lightmap_multiplier(RID p_baked_light);
void VisualServerRaster::baked_light_set_octree(RID p_baked_light, const DVector<uint8_t> p_octree);
DVector<uint8_t> VisualServerRaster::baked_light_get_octree(RID p_baked_light);
void VisualServerRaster::baked_light_set_light(RID p_baked_light, const DVector<uint8_t> p_light);
DVector<uint8_t> VisualServerRaster::baked_light_get_light(RID p_baked_light);
void VisualServerRaster::baked_light_set_sampler_octree(RID p_baked_light, const DVector<int> &p_sampler);
DVector<int> VisualServerRaster::baked_light_get_sampler_octree(RID p_baked_light);
void VisualServerRaster::baked_light_add_lightmap(RID p_baked_light, const RID p_texture, int p_id);
void VisualServerRaster::baked_light_clear_lightmaps(RID p_baked_light);
void VisualServerRaster::baked_light_set_realtime_color_enabled(RID p_baked_light, const bool p_enabled);
bool VisualServerRaster::baked_light_get_realtime_color_enabled(RID p_baked_light);
void VisualServerRaster::baked_light_set_realtime_color(RID p_baked_light, const Color &p_color);
Color VisualServerRaster::baked_light_get_realtime_color(RID p_baked_light);
void VisualServerRaster::baked_light_set_realtime_energy(RID p_baked_light, const float p_energy);
float VisualServerRaster::baked_light_get_realtime_energy(RID p_baked_light);
RID VisualServerRaster::baked_light_sampler_create();
void VisualServerRaster::baked_light_sampler_set_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param, float p_value);
float VisualServerRaster::baked_light_sampler_get_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param);
void VisualServerRaster::_update_baked_light_sampler_dp_cache(BakedLightSampler *blsamp);
void VisualServerRaster::baked_light_sampler_set_resolution(RID p_baked_light_sampler, int p_resolution);
int VisualServerRaster::baked_light_sampler_get_resolution(RID p_baked_light_sampler);
void VisualServerRaster::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far);
void VisualServerRaster::camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far);
void VisualServerRaster::camera_set_transform(RID p_camera, const Transform &p_transform);
void VisualServerRaster::camera_set_visible_layers(RID p_camera, uint32_t p_layers);
uint32_t VisualServerRaster::camera_get_visible_layers(RID p_camera);
void VisualServerRaster::camera_set_environment(RID p_camera, RID p_env);
RID VisualServerRaster::camera_get_environment(RID p_camera);
void VisualServerRaster::camera_set_use_vertical_aspect(RID p_camera, bool p_enable);
bool VisualServerRaster::camera_is_using_vertical_aspect(RID p_camera, bool p_enable);
RID VisualServerRaster::viewport_create();
void VisualServerRaster::viewport_attach_to_screen(RID p_viewport, int p_screen);
void VisualServerRaster::viewport_detach(RID p_viewport);
void VisualServerRaster::viewport_set_as_render_target(RID p_viewport, bool p_enable);
void VisualServerRaster::viewport_set_render_target_update_mode(RID p_viewport, RenderTargetUpdateMode p_mode);
VisualServer::RenderTargetUpdateMode VisualServerRaster::viewport_get_render_target_update_mode(RID p_viewport);
RID VisualServerRaster::viewport_get_render_target_texture(RID p_viewport);
void VisualServerRaster::viewport_set_render_target_vflip(RID p_viewport, bool p_enable);
void VisualServerRaster::viewport_set_render_target_clear_on_new_frame(RID p_viewport, bool p_enable);
void VisualServerRaster::viewport_set_render_target_to_screen_rect(RID p_viewport, const Rect2 &p_rect);
bool VisualServerRaster::viewport_get_render_target_vflip(RID p_viewport);
bool VisualServerRaster::viewport_get_render_target_clear_on_new_frame(RID p_viewport);
void VisualServerRaster::viewport_render_target_clear(RID p_viewport);
void VisualServerRaster::viewport_queue_screen_capture(RID p_viewport);
Image VisualServerRaster::viewport_get_screen_capture(RID p_viewport);
void VisualServerRaster::viewport_set_rect(RID p_viewport, const ViewportRect &p_rect);
VisualServer::ViewportRect VisualServerRaster::viewport_get_rect(RID p_viewport);
void VisualServerRaster::viewport_set_hide_scenario(RID p_viewport, bool p_hide);
void VisualServerRaster::viewport_set_hide_canvas(RID p_viewport, bool p_hide);
void VisualServerRaster::viewport_set_disable_environment(RID p_viewport, bool p_disable);
void VisualServerRaster::viewport_attach_camera(RID p_viewport, RID p_camera);
void VisualServerRaster::viewport_set_scenario(RID p_viewport, RID p_scenario);
RID VisualServerRaster::viewport_get_attached_camera(RID p_viewport);
void VisualServerRaster::viewport_attach_canvas(RID p_viewport, RID p_canvas);
void VisualServerRaster::viewport_set_canvas_transform(RID p_viewport, RID p_canvas, const Matrix32 &p_transform);
Matrix32 VisualServerRaster::viewport_get_canvas_transform(RID p_viewport, RID p_canvas);
void VisualServerRaster::viewport_set_global_canvas_transform(RID p_viewport, const Matrix32 &p_transform);
Matrix32 VisualServerRaster::viewport_get_global_canvas_transform(RID p_viewport);
void VisualServerRaster::viewport_remove_canvas(RID p_viewport, RID p_canvas);
void VisualServerRaster::viewport_set_canvas_layer(RID p_viewport, RID p_canvas, int p_layer);
void VisualServerRaster::viewport_set_transparent_background(RID p_viewport, bool p_enabled);
bool VisualServerRaster::viewport_has_transparent_background(RID p_viewport);
RID VisualServerRaster::viewport_get_scenario(RID p_viewport);
RID VisualServerRaster::environment_create();
void VisualServerRaster::environment_set_background(RID p_env, EnvironmentBG p_bg);
VisualServer::EnvironmentBG VisualServerRaster::environment_get_background(RID p_env);
void VisualServerRaster::environment_set_background_param(RID p_env, EnvironmentBGParam p_param, const Variant &p_value);
Variant VisualServerRaster::environment_get_background_param(RID p_env, EnvironmentBGParam p_param);
void VisualServerRaster::environment_set_enable_fx(RID p_env, EnvironmentFx p_effect, bool p_enabled);
bool VisualServerRaster::environment_is_fx_enabled(RID p_env, EnvironmentFx p_effect);
void VisualServerRaster::environment_fx_set_param(RID p_env, EnvironmentFxParam p_param, const Variant &p_value);
Variant VisualServerRaster::environment_fx_get_param(RID p_env, EnvironmentFxParam p_param);
void VisualServerRaster::_dependency_queue_update(RID p_rid, bool p_update_aabb, bool p_update_materials);
void VisualServerRaster::_instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_materials);
RID VisualServerRaster::scenario_create();
void VisualServerRaster::scenario_set_debug(RID p_scenario, ScenarioDebugMode p_debug_mode);
void VisualServerRaster::scenario_set_environment(RID p_scenario, RID p_environment);
void VisualServerRaster::scenario_set_fallback_environment(RID p_scenario, RID p_environment);
RID VisualServerRaster::scenario_get_environment(RID p_scenario, RID p_environment);
RID VisualServerRaster::instance_create();
void VisualServerRaster::instance_set_base(RID p_instance, RID p_base);
RID VisualServerRaster::instance_get_base(RID p_instance);
void VisualServerRaster::instance_set_scenario(RID p_instance, RID p_scenario);
RID VisualServerRaster::instance_get_scenario(RID p_instance);
void VisualServerRaster::instance_set_layer_mask(RID p_instance, uint32_t p_mask);
uint32_t VisualServerRaster::instance_get_layer_mask(RID p_instance);
AABB VisualServerRaster::instance_get_base_aabb(RID p_instance);
void VisualServerRaster::instance_attach_object_instance_ID(RID p_instance, uint32_t p_ID);
uint32_t VisualServerRaster::instance_get_object_instance_ID(RID p_instance);
void VisualServerRaster::instance_attach_skeleton(RID p_instance, RID p_skeleton);
RID VisualServerRaster::instance_get_skeleton(RID p_instance);
void VisualServerRaster::instance_set_morph_target_weight(RID p_instance, int p_shape, float p_weight);
float VisualServerRaster::instance_get_morph_target_weight(RID p_instance, int p_shape);
void VisualServerRaster::instance_set_surface_material(RID p_instance, int p_surface, RID p_material);
void VisualServerRaster::instance_set_transform(RID p_instance, const Transform &p_transform);
Transform VisualServerRaster::instance_get_transform(RID p_instance);
void VisualServerRaster::instance_set_exterior(RID p_instance, bool p_enabled);
bool VisualServerRaster::instance_is_exterior(RID p_instance);
void VisualServerRaster::instance_set_room(RID p_instance, RID p_room);
RID VisualServerRaster::instance_get_room(RID p_instance);
void VisualServerRaster::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin);
real_t VisualServerRaster::instance_get_extra_visibility_margin(RID p_instance);
Vector<RID> VisualServerRaster::instances_cull_aabb(const AABB &p_aabb, RID p_scenario);
Vector<RID> VisualServerRaster::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario);
Vector<RID> VisualServerRaster::instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario);
void VisualServerRaster::instance_geometry_set_flag(RID p_instance, InstanceFlags p_flags, bool p_enabled);
bool VisualServerRaster::instance_geometry_get_flag(RID p_instance, InstanceFlags p_flags);
void VisualServerRaster::instance_geometry_set_cast_shadows_setting(RID p_instance, VS::ShadowCastingSetting p_shadow_casting_setting);
VS::ShadowCastingSetting VisualServerRaster::instance_geometry_get_cast_shadows_setting(RID p_instance);
void VisualServerRaster::instance_geometry_set_material_override(RID p_instance, RID p_material);
RID VisualServerRaster::instance_geometry_get_material_override(RID p_instance);
void VisualServerRaster::instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max);
float VisualServerRaster::instance_geometry_get_draw_range_min(RID p_instance);
float VisualServerRaster::instance_geometry_get_draw_range_max(RID p_instance);
void VisualServerRaster::instance_geometry_set_baked_light(RID p_instance, RID p_baked_light);
RID VisualServerRaster::instance_geometry_get_baked_light(RID p_instance);
void VisualServerRaster::instance_geometry_set_baked_light_sampler(RID p_instance, RID p_baked_light_sampler);
RID VisualServerRaster::instance_geometry_get_baked_light_sampler(RID p_instance);
void VisualServerRaster::instance_geometry_set_baked_light_texture_index(RID p_instance, int p_tex_id);
int VisualServerRaster::instance_geometry_get_baked_light_texture_index(RID p_instance);
void VisualServerRaster::_update_instance(Instance *p_instance);
void VisualServerRaster::_update_instance_aabb(Instance *p_instance);
void VisualServerRaster::_update_instances();
void VisualServerRaster::instance_light_set_enabled(RID p_instance, bool p_enabled);
bool VisualServerRaster::instance_light_is_enabled(RID p_instance);
RID VisualServerRaster::canvas_create();
void VisualServerRaster::canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring);
Point2 VisualServerRaster::canvas_get_item_mirroring(RID p_canvas, RID p_item);
void VisualServerRaster::canvas_set_modulate(RID p_canvas, const Color &p_color);
RID VisualServerRaster::canvas_item_create();
void VisualServerRaster::canvas_item_set_parent(RID p_item, RID p_parent);
RID VisualServerRaster::canvas_item_get_parent(RID p_canvas_item);
void VisualServerRaster::canvas_item_set_visible(RID p_item, bool p_visible);
bool VisualServerRaster::canvas_item_is_visible(RID p_item);
void VisualServerRaster::canvas_item_set_light_mask(RID p_canvas_item, int p_mask);
void VisualServerRaster::canvas_item_set_blend_mode(RID p_canvas_item, MaterialBlendMode p_blend);
void VisualServerRaster::canvas_item_attach_viewport(RID p_canvas_item, RID p_viewport);
void VisualServerRaster::canvas_item_set_clip(RID p_item, bool p_clip);
void VisualServerRaster::canvas_item_set_distance_field_mode(RID p_item, bool p_distance_field);
void VisualServerRaster::canvas_item_set_transform(RID p_item, const Matrix32 &p_transform);
void VisualServerRaster::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect);
void VisualServerRaster::canvas_item_set_opacity(RID p_item, float p_opacity);
float VisualServerRaster::canvas_item_get_opacity(RID p_item, float p_opacity);
void VisualServerRaster::canvas_item_set_on_top(RID p_item, bool p_on_top);
bool VisualServerRaster::canvas_item_is_on_top(RID p_item);
void VisualServerRaster::canvas_item_set_self_opacity(RID p_item, float p_self_opacity);
float VisualServerRaster::canvas_item_get_self_opacity(RID p_item, float p_self_opacity);
void VisualServerRaster::canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width);
void VisualServerRaster::canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color);
void VisualServerRaster::canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color);
void VisualServerRaster::canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile, const Color &p_modulate, bool p_transpose);
void VisualServerRaster::canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose);
void VisualServerRaster::canvas_item_add_style_box(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, bool p_draw_center, const Color &p_modulate);
void VisualServerRaster::canvas_item_add_primitive(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width);
void VisualServerRaster::canvas_item_add_polygon(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture);
void VisualServerRaster::canvas_item_add_triangle_array_ptr(RID p_item, int p_count, const int *p_indices, const Point2 *p_points, const Color *p_colors, const Point2 *p_uvs, RID p_texture);
void VisualServerRaster::canvas_item_add_triangle_array(RID p_item, const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, int p_count);
void VisualServerRaster::canvas_item_add_set_transform(RID p_item, const Matrix32 &p_transform);
void VisualServerRaster::canvas_item_add_set_blend_mode(RID p_item, MaterialBlendMode p_blend);
void VisualServerRaster::canvas_item_set_z(RID p_item, int p_z);
void VisualServerRaster::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable);
void VisualServerRaster::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect);
void VisualServerRaster::canvas_item_set_use_parent_material(RID p_item, bool p_enable);
void VisualServerRaster::canvas_item_set_material(RID p_item, RID p_material);
void VisualServerRaster::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable);
void VisualServerRaster::canvas_item_add_clip_ignore(RID p_item, bool p_ignore);
void VisualServerRaster::canvas_item_clear(RID p_item);
void VisualServerRaster::canvas_item_raise(RID p_item);
RID VisualServerRaster::canvas_light_create();
void VisualServerRaster::canvas_light_attach_to_canvas(RID p_light, RID p_canvas);
void VisualServerRaster::canvas_light_set_enabled(RID p_light, bool p_enabled);
void VisualServerRaster::canvas_light_set_transform(RID p_light, const Matrix32 &p_transform);
void VisualServerRaster::canvas_light_set_scale(RID p_light, float p_scale);
void VisualServerRaster::canvas_light_set_texture(RID p_light, RID p_texture);
void VisualServerRaster::canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset);
void VisualServerRaster::canvas_light_set_color(RID p_light, const Color &p_color);
void VisualServerRaster::canvas_light_set_height(RID p_light, float p_height);
void VisualServerRaster::canvas_light_set_energy(RID p_light, float p_energy);
void VisualServerRaster::canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z);
void VisualServerRaster::canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer);
void VisualServerRaster::canvas_light_set_item_mask(RID p_light, int p_mask);
void VisualServerRaster::canvas_light_set_item_shadow_mask(RID p_light, int p_mask);
void VisualServerRaster::canvas_light_set_mode(RID p_light, CanvasLightMode p_mode);
void VisualServerRaster::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled);
void VisualServerRaster::canvas_light_set_shadow_buffer_size(RID p_light, int p_size);
void VisualServerRaster::canvas_light_set_shadow_esm_multiplier(RID p_light, float p_multiplier);
void VisualServerRaster::canvas_light_set_shadow_color(RID p_light, const Color &p_color);
RID VisualServerRaster::canvas_light_occluder_create();
void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas);
void VisualServerRaster::canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled);
void VisualServerRaster::canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon);
void VisualServerRaster::canvas_light_occluder_set_transform(RID p_occluder, const Matrix32 &p_xform);
void VisualServerRaster::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask);
RID VisualServerRaster::canvas_occluder_polygon_create();
void VisualServerRaster::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const DVector<Vector2> &p_shape, bool p_close);
void VisualServerRaster::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const DVector<Vector2> &p_shape);
void VisualServerRaster::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, CanvasOccluderPolygonCullMode p_mode);
RID VisualServerRaster::canvas_item_material_create();
void VisualServerRaster::canvas_item_material_set_shader(RID p_material, RID p_shader);
void VisualServerRaster::canvas_item_material_set_shader_param(RID p_material, const StringName &p_param, const Variant &p_value);
Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material, const StringName &p_param);
void VisualServerRaster::canvas_item_material_set_shading_mode(RID p_material, CanvasItemShadingMode p_mode);
void VisualServerRaster::cursor_set_rotation(float p_rotation, int p_cursor);
void VisualServerRaster::cursor_set_texture(RID p_texture, const Point2 &p_center_offset, int p_cursor, const Rect2 &p_region);
void VisualServerRaster::cursor_set_visible(bool p_visible, int p_cursor);
void VisualServerRaster::cursor_set_pos(const Point2 &p_pos, int p_cursor);
void VisualServerRaster::black_bars_set_margins(int p_left, int p_top, int p_right, int p_bottom);
void VisualServerRaster::black_bars_set_images(RID p_left, RID p_top, RID p_right, RID p_bottom);
void VisualServerRaster::_free_attached_instances(RID p_rid, bool p_free_scenario);
void VisualServerRaster::custom_shade_model_set_shader(int p_model, RID p_shader);
RID VisualServerRaster::custom_shade_model_get_shader(int p_model);
void VisualServerRaster::custom_shade_model_set_name(int p_model, const String &p_name);
String VisualServerRaster::custom_shade_model_get_name(int p_model);
void VisualServerRaster::custom_shade_model_set_param_info(int p_model, const List<PropertyInfo> &p_info);
void VisualServerRaster::custom_shade_model_get_param_info(int p_model, List<PropertyInfo> *p_info);
void VisualServerRaster::free(RID p_rid);
void VisualServerRaster::_instance_draw(Instance *p_instance);
Vector<Vector3> VisualServerRaster::_camera_generate_endpoints(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max);
Vector<Plane> VisualServerRaster::_camera_generate_orthogonal_planes(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max);
void VisualServerRaster::_light_instance_update_pssm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range);
CameraMatrix _lispm_look(const Vector3 pos, const Vector3 dir, const Vector3 up);
void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range);
void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range);
void VisualServerRaster::_light_instance_update_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range);
void VisualServerRaster::_portal_disconnect(Instance *p_portal, bool p_cleanup);
void VisualServerRaster::_instance_validate_autorooms(Instance *p_geometry);
void VisualServerRaster::_portal_attempt_connect(Instance *p_portal);
void *VisualServerRaster::instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int);
void VisualServerRaster::instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *);
bool VisualServerRaster::_test_portal_cull(Camera *p_camera, Instance *p_from_portal, Instance *p_to_portal);
void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal, Instance *p_from_portal);
void VisualServerRaster::_cull_room(Camera *p_camera, Instance *p_room, Instance *p_from_portal);
void VisualServerRaster::_process_sampled_light(const Transform &p_camera, Instance *p_sampled_light, bool p_linear_colorspace);
void VisualServerRaster::_render_no_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario);
void VisualServerRaster::_render_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario);
void VisualServerRaster::_render_canvas_item_tree(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, Rasterizer::CanvasLight *p_lights);
void VisualServerRaster::_render_canvas_item_viewport(VisualServer *p_self, void *p_vp, const Rect2 &p_rect);
void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, float p_opacity, int p_z, Rasterizer::CanvasItem **z_list, Rasterizer::CanvasItem **z_last_list, CanvasItem *p_canvas_clip, CanvasItem *p_material_owner);
void VisualServerRaster::_light_mask_canvas_items(int p_z, Rasterizer::CanvasItem *p_canvas_item, Rasterizer::CanvasLight *p_masked_lights);
void VisualServerRaster::_render_canvas(Canvas *p_canvas, const Matrix32 &p_transform, Rasterizer::CanvasLight *p_lights, Rasterizer::CanvasLight *p_masked_lights);
void VisualServerRaster::_draw_viewport_camera(Viewport *p_viewport, bool p_ignore_camera);
void VisualServerRaster::_draw_viewport(Viewport *p_viewport, int p_ofs_x, int p_ofs_y, int p_parent_w, int p_parent_h);
void VisualServerRaster::_draw_viewports();
void VisualServerRaster::_draw_cursors_and_margins();
void VisualServerRaster::sync();
void VisualServerRaster::draw();
bool VisualServerRaster::has_changed();
int VisualServerRaster::get_render_info(RenderInfo p_info);
bool VisualServerRaster::has_feature(Features p_feature);
void VisualServerRaster::set_default_clear_color(const Color &p_color);
Color VisualServerRaster::get_default_clear_color();
void VisualServerRaster::set_time_scale(float p_scale);
void VisualServerRaster::set_boot_image(const Image &p_image, const Color &p_color, bool p_scale);
void VisualServerRaster::init();
void VisualServerRaster::_clean_up_owner(RID_OwnerBase *p_owner, String p_type);
void VisualServerRaster::finish();
RID VisualServerRaster::get_test_cube();
VisualServerRaster::VisualServerRaster(Rasterizer *p_rasterizer);
VisualServerRaster::~VisualServerRaster();
| 6545c274d355c027e2e8f9289f588bc7fa06582af2a3c8cc78faa8da9fd78e0c | 118 |
|
opticode | pyviennacl-dev | src/_viennacl/platform_support.cpp | get_opencl_handle |
vcl::vcl_size_t get_opencl_handle(vcl::backend::mem_handle& m) {
return (vcl::vcl_size_t) m.opencl_handle().get();
} |
vcl::vcl_size_t get_ram_handle(vcl::backend::mem_handle& m);
void set_ram_handle(vcl::backend::mem_handle& m, vcl::vcl_size_t ptr);
void set_opencl_handle(vcl::backend::mem_handle& m, vcl::vcl_size_t ptr);
const vcl::ocl::context& get_opencl_handle_context(vcl::backend::mem_handle& m);
vcl::vcl_size_t get_cuda_handle(vcl::backend::mem_handle& m);
void set_cuda_handle(vcl::backend::mem_handle& m, vcl::vcl_size_t ptr);
PYVCL_SUBMODULE(platform_support);
| afab933ad2ae064f79a1bf63d9987c8d262ff16cdcd9afc5def31fd4a4964bd1 | 119 |
|
MatejGomboc | Neural-Networks | neural_networks/neural_networks_code/src/population.cpp | Mutation_params::get_prob_mut_neuron_steepness | double Mutation_params::get_prob_mut_neuron_steepness(void) const
{
return m_dProb_mut_neuron_steepness;
} | double Mutation_params::get_prob_mut_neuron_weight(void);
double Mutation_params::get_prob_mut_output_weight(void);
double Mutation_params::get_prob_mut_neuron_treshold(void);
double Mutation_params::get_prob_mut_neuron_simetricity(void);
void Mutation_params::set_prob_mut_neuron_weight(double probability);
void Mutation_params::set_prob_mut_output_weight(double probability);
void Mutation_params::set_prob_mut_neuron_treshold(double probability);
void Mutation_params::set_prob_mut_neuron_steepness(double probability);
void Mutation_params::set_prob_mut_neuron_simetricity(double probability);
Population::Population(std::vector<std::shared_ptr<Member>>& p_members);
Population::~Population(void);
void Population::check_members(void);
void Population::calculate_outputs(void);
double Population::mutate_value(const double probability, const double min_value, const double max_value, );
void Population::mutate(void);
void Population::mate(void);
unsigned long Population::roulette_wheel(void);
unsigned long Population::roulette_wheel(const unsigned long dropped_memb_indx);
unsigned long Population::roulette_wheel(const std::set<const unsigned long>& dropped_memb_indices);
| 5919ed065c768c5e5ad952dc466daa35320bf7867b679d190d3661868522fa1c | 111 |
|
cutelyst | grantlee | templates/defaulttags/mediafinder.cpp | MediaFinderNodeFactory::getNode |
Grantlee::Node* MediaFinderNodeFactory::getNode( const QString& tagContent, Parser* p ) const
{
QStringList expr = smartSplit( tagContent );
if ( expr.size() <= 1 ) {
throw Grantlee::Exception( TagSyntaxError, QStringLiteral( "'media_finder' tag requires at least one argument" ) );
}
expr.takeAt( 0 );
return new MediaFinderNode( getFilterExpressionList( expr, p ), p );
} |
MediaFinderNodeFactory::MediaFinderNodeFactory();
MediaFinderNode::MediaFinderNode( QList<FilterExpression> mediaExpressionList, QObject* parent );
void MediaFinderNode::render( OutputStream *stream, Context* c );
| a3308c333bd8d0f2fccee3c0dc73352ee0c56a67b5650458aa9817c67c37d88c | 390 |
|
kevL | 0xC_kL | src/Ruleset/Ruleset.cpp | Ruleset::getAlienMission |
const RuleAlienMission* Ruleset::getAlienMission(const std::string& type) const
{
std::map<std::string, RuleAlienMission*>::const_iterator i (_alienMissions.find(type));
if (i != _alienMissions.end())
return i->second;
return nullptr;
} |
Ruleset::Ruleset(const Game* const game);
Ruleset::~Ruleset();
void Ruleset::reloadCountryLines();
void Ruleset::validateMissions();
void Ruleset::load(const std::string& src);
void Ruleset::loadFiles(const std::string& dir);
void Ruleset::loadFile(const std::string& file);
SavedGame* Ruleset::createSave(Game* const play);
const std::vector<OperationPool*>& Ruleset::getOperations();
RuleCountry* Ruleset::getCountry(const std::string& id);
const std::vector<std::string>& Ruleset::getCountriesList();
RuleRegion* Ruleset::getRegion(const std::string& id);
const std::vector<std::string>& Ruleset::getRegionsList();
RuleBaseFacility* Ruleset::getBaseFacility(const std::string& id);
const std::vector<std::string>& Ruleset::getBaseFacilitiesList();
RuleCraft* Ruleset::getCraft(const std::string& id);
const std::vector<std::string>& Ruleset::getCraftsList();
RuleCraftWeapon* Ruleset::getCraftWeapon(const std::string& id);
const std::vector<std::string>& Ruleset::getCraftWeaponsList();
RuleItem* Ruleset::getItemRule(const std::string& id);
const std::vector<std::string>& Ruleset::getItemsList();
RuleUfo* Ruleset::getUfo(const std::string& id);
const std::vector<std::string>& Ruleset::getUfosList();
RuleTerrain* Ruleset::getTerrain(const std::string& type);
const std::vector<std::string>& Ruleset::getTerrainList();
MapDataSet* Ruleset::getMapDataSet(const std::string& type);
const std::map<std::string, const RuleAward*>& Ruleset::getAwardsList();
RuleSoldier* Ruleset::getSoldier(const std::string& type);
const std::vector<std::string>& Ruleset::getSoldiersList();
RuleUnit* Ruleset::getUnitRule(const std::string& type);
RuleAlienRace* Ruleset::getAlienRace(const std::string& type);
const std::vector<std::string>& Ruleset::getAlienRacesList();
RuleAlienDeployment* Ruleset::getDeployment(const std::string& type);
const std::vector<std::string>& Ruleset::getDeploymentsList();
RuleArmor* Ruleset::getArmor(const std::string& type);
const std::vector<std::string>& Ruleset::getArmorsList();
int Ruleset::getEngineerCost();
int Ruleset::getScientistCost();
int Ruleset::getPersonnelTime();
ArticleDefinition* Ruleset::getUfopaediaArticle(const std::string& article_id);
const std::vector<std::string>& Ruleset::getUfopaediaList();
std::map<std::string, RuleInventory*>* Ruleset::getInventories();
const RuleInventory* Ruleset::getInventory(const std::string& type);
const RuleInventory* Ruleset::getInventoryRule(InventorySection sectionId);
void Ruleset::convertInventories();
int Ruleset::getHighestDropCost();
const RuleResearch* Ruleset::getResearch(const std::string& type);
const std::vector<std::string>& Ruleset::getResearchList();
RuleManufacture* Ruleset::getManufacture(const std::string& type);
const std::vector<std::string>& Ruleset::getManufactureList();
std::vector<RuleBaseFacility*> Ruleset::getStartFacilities();
const UfoTrajectory* Ruleset::getUfoTrajectory(const std::string& type);
const std::vector<std::string>& Ruleset::getAlienMissionList();
const std::vector<std::vector<int>>& Ruleset::getAlienItemLevels();
const YAML::Node& Ruleset::getStartBase();
MCDPatch* Ruleset::getMCDPatch(const std::string& type);
std::vector<std::pair<std::string, RuleMusic*>> Ruleset::getMusicTracks();
std::vector<std::pair<std::string, ExtraSprites*>> Ruleset::getExtraSprites();
std::vector<std::pair<std::string, ExtraSounds*>> Ruleset::getExtraSounds();
std::map<std::string, ExtraStrings*> Ruleset::getExtraStrings();
bool operator();
CompareRule(Ruleset* ruleset);
bool operator();
CompareRule(Ruleset* const ruleset);
bool operator();
bool operator();
void Ruleset::sortLists();
const std::string& Ruleset::getAlienFuelType();
int Ruleset::getAlienFuelQuantity();
std::string Ruleset::getFontName();
int Ruleset::getRadarRangeBest();
int Ruleset::getRadarRangeCutoff();
int Ruleset::getFirstGrenade();
int Ruleset::getRetaliation();
RuleInterface* Ruleset::getInterface(const std::string& id);
RuleGlobe* Ruleset::getGlobe();
const std::map<std::string, RuleVideo*>* Ruleset::getVideos();
const std::vector<std::string>* Ruleset::getMissionScriptList();
RuleMissionScript* Ruleset::getMissionScript(const std::string& type);
const std::vector<RuleMapScript*>* Ruleset::getMapScripts(const std::string& type);
const std::string& Ruleset::getFinalResearch();
int Ruleset::getDefeatFunds();
int Ruleset::getDefeatScore();
int Ruleset::getBaseLostScore();
const Game* Ruleset::getGame();
| 72882da10abc4cec3bc99f9a93a2022dddf234cf26cf2ce96a53d731231e8e6e | 243 |
|
01org | vmf | 3rdparty/cryptopp/basecode.cpp | BaseN_Decoder::Put2 |
size_t BaseN_Decoder::Put2(const byte *begin, size_t length, int messageEnd, bool blocking)
{
FILTER_BEGIN;
while (m_inputPosition < length)
{
unsigned int value;
value = m_lookup[begin[m_inputPosition++]];
if (value >= 256)
continue;
if (m_bytePos == 0 && m_bitPos == 0)
memset(m_outBuf, 0, m_outputBlockSize);
{
int newBitPos = m_bitPos + m_bitsPerChar;
if (newBitPos <= 8)
m_outBuf[m_bytePos] |= value << (8-newBitPos);
else
{
m_outBuf[m_bytePos] |= value >> (newBitPos-8);
m_outBuf[m_bytePos+1] |= value << (16-newBitPos);
}
m_bitPos = newBitPos;
while (m_bitPos >= 8)
{
m_bitPos -= 8;
++m_bytePos;
}
}
if (m_bytePos == m_outputBlockSize)
{
FILTER_OUTPUT(1, m_outBuf, m_outputBlockSize, 0);
m_bytePos = m_bitPos = 0;
}
}
if (messageEnd)
{
FILTER_OUTPUT(2, m_outBuf, m_bytePos, messageEnd);
m_bytePos = m_bitPos = 0;
}
FILTER_END_NO_MESSAGE_END;
} |
void BaseN_Encoder::IsolatedInitialize(const NameValuePairs ¶meters);
size_t BaseN_Encoder::Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
void BaseN_Decoder::IsolatedInitialize(const NameValuePairs ¶meters);
void BaseN_Decoder::InitializeDecodingLookupArray(int *lookup, const byte *alphabet, unsigned int base, bool caseInsensitive);
void Grouper::IsolatedInitialize(const NameValuePairs ¶meters);
size_t Grouper::Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
| 54506f42e43a373f3c78806887c77605f222dacd99e127595879aeff11e3c2c2 | 987 |
|
Bloodknight | Torque3D | Engine/lib/assimp/code/AssetLib/Terragen/TerragenLoader.cpp | TerragenImporter::InternReadFile |
void TerragenImporter::InternReadFile(const std::string &pFile,
aiScene *pScene, IOSystem *pIOHandler) {
IOStream *file = pIOHandler->Open(pFile, "rb");
if (file == nullptr)
throw DeadlyImportError("Failed to open TERRAGEN TERRAIN file ", pFile, ".");
StreamReaderLE reader(file);
if (reader.GetRemainingSize() < 16)
throw DeadlyImportError("TER: file is too small");
if (::strncmp((const char *)reader.GetPtr(), AI_TERR_BASE_STRING, 8))
throw DeadlyImportError("TER: Magic string \'TERRAGEN\' not found");
if (::strncmp((const char *)reader.GetPtr() + 8, AI_TERR_TERRAIN_STRING, 8))
throw DeadlyImportError("TER: Magic string \'TERRAIN\' not found");
unsigned int x = 0, y = 0, mode = 0;
aiNode *root = pScene->mRootNode = new aiNode();
root->mName.Set("<TERRAGEN.TERRAIN>");
root->mTransformation.a1 = root->mTransformation.b2 = root->mTransformation.c3 = 30.f;
reader.IncPtr(16);
while (reader.GetRemainingSize() >= 4) {
const char *head = (const char *)reader.GetPtr();
reader.IncPtr(4);
if (!::strncmp(head, AI_TERR_EOF_STRING, 4))
break;
if (!::strncmp(head, AI_TERR_CHUNK_XPTS, 4)) {
x = (uint16_t)reader.GetI2();
}
else if (!::strncmp(head, AI_TERR_CHUNK_YPTS, 4)) {
y = (uint16_t)reader.GetI2();
}
else if (!::strncmp(head, AI_TERR_CHUNK_SIZE, 4)) {
x = y = (uint16_t)reader.GetI2() + 1;
}
else if (!::strncmp(head, AI_TERR_CHUNK_SCAL, 4)) {
root->mTransformation.a1 = reader.GetF4();
root->mTransformation.b2 = reader.GetF4();
root->mTransformation.c3 = reader.GetF4();
}
else if (!::strncmp(head, AI_TERR_CHUNK_CRAD, 4)) {
reader.GetF4();
}
else if (!::strncmp(head, AI_TERR_CHUNK_CRVM, 4)) {
mode = reader.GetI1();
if (0 != mode)
ASSIMP_LOG_ERROR("TER: Unsupported mapping mode, a flat terrain is returned");
}
else if (!::strncmp(head, AI_TERR_CHUNK_ALTW, 4)) {
float hscale = (float)reader.GetI2() / 65536;
float bheight = (float)reader.GetI2();
if (!hscale) hscale = 1;
if (reader.GetRemainingSize() < x * y * 2)
throw DeadlyImportError("TER: ALTW chunk is too small");
if (x <= 1 || y <= 1)
throw DeadlyImportError("TER: Invalid terrain size");
pScene->mMeshes = new aiMesh *[pScene->mNumMeshes = 1];
aiMesh *m = pScene->mMeshes[0] = new aiMesh();
aiFace *f = m->mFaces = new aiFace[m->mNumFaces = (x - 1) * (y - 1)];
aiVector3D *pv = m->mVertices = new aiVector3D[m->mNumVertices = m->mNumFaces * 4];
aiVector3D *uv(nullptr);
float step_y(0.0f), step_x(0.0f);
if (configComputeUVs) {
uv = m->mTextureCoords[0] = new aiVector3D[m->mNumVertices];
step_y = 1.f / y;
step_x = 1.f / x;
}
const int16_t *data = (const int16_t *)reader.GetPtr();
for (unsigned int yy = 0, t = 0; yy < y - 1; ++yy) {
for (unsigned int xx = 0; xx < x - 1; ++xx, ++f) {
const float fy = (float)yy, fx = (float)xx;
unsigned tmp, tmp2;
*pv++ = aiVector3D(fx, fy, (float)data[(tmp2 = x * yy) + xx] * hscale + bheight);
*pv++ = aiVector3D(fx, fy + 1, (float)data[(tmp = x * (yy + 1)) + xx] * hscale + bheight);
*pv++ = aiVector3D(fx + 1, fy + 1, (float)data[tmp + xx + 1] * hscale + bheight);
*pv++ = aiVector3D(fx + 1, fy, (float)data[tmp2 + xx + 1] * hscale + bheight);
if (configComputeUVs) {
*uv++ = aiVector3D(step_x * xx, step_y * yy, 0.f);
*uv++ = aiVector3D(step_x * xx, step_y * (yy + 1), 0.f);
*uv++ = aiVector3D(step_x * (xx + 1), step_y * (yy + 1), 0.f);
*uv++ = aiVector3D(step_x * (xx + 1), step_y * yy, 0.f);
}
f->mIndices = new unsigned int[f->mNumIndices = 4];
for (unsigned int i = 0; i < 4; ++i) {
f->mIndices[i] = t;
t++;
}
}
}
root->mMeshes = new unsigned int[root->mNumMeshes = 1];
root->mMeshes[0] = 0;
}
unsigned dtt = reader.GetCurrentPos();
if (dtt & 0x3) {
reader.IncPtr(4 - dtt);
}
}
if (pScene->mNumMeshes != 1)
throw DeadlyImportError("TER: Unable to load terrain");
pScene->mFlags |= AI_SCENE_FLAGS_TERRAIN;
} |
TerragenImporter::TerragenImporter();
TerragenImporter::~TerragenImporter();
bool TerragenImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/);
const aiImporterDesc *TerragenImporter::GetInfo();
void TerragenImporter::SetupProperties(const Importer *pImp);
| 99d2c6543c94d4fb9d6b66c79cf7f62c185d4ef5f6d07897ae705ffdb936221b | 5,113 |
|
digama0 | lean | src/library/tactic/rewrite_tactic.cpp |
rewrite_cfg::rewrite_cfg |
rewrite_cfg::rewrite_cfg(vm_obj const & cfg):apply_cfg(cfield(cfg, 0)) {
m_symm = to_bool(cfield(cfg, 1));
m_occs = to_occurrences(cfield(cfg, 2));
} |
static vm_obj rewrite_core(expr h, expr e, rewrite_cfg const & cfg, tactic_state s);
vm_obj tactic_rewrite_core(vm_obj const & h, vm_obj const & e, vm_obj const & cfg, vm_obj const & s);
void initialize_rewrite_tactic();
void finalize_rewrite_tactic();
| 89b1d30ea858db867f7ccdbe4ae29781092e8c7078ff6476a2ed4202f649ca2a | 158 |
|
TheCoSMoCompany | biopredyn | Prototype/src/libsbml-5.10.0/src/sbml/math/ASTCnExponentialNode.cpp |
ASTCnExponentialNode::ASTCnExponentialNode |
ASTCnExponentialNode::ASTCnExponentialNode (const ASTCnExponentialNode& orig):
ASTCnBase(orig)
, mExponent (orig.mExponent)
, mMantissa (orig.mMantissa)
, mIsSetMantissa (orig.mIsSetMantissa)
, mIsSetExponent (orig.mIsSetExponent)
{
} |
ASTCnExponentialNode::~ASTCnExponentialNode ();
| 1c24e9c567e4ebdf3d7b50a00c300dcd7553241dd785663e28a340fbad905ba1 | 267 |
|
Ruscris2 | RC-Engine | RC-Engine/RenderDummy.cpp | RenderDummy::Render |
void RenderDummy::Render(VulkanInterface * vulkan, VulkanCommandBuffer * commandBuffer, VulkanPipeline * vulkanPipeline,
glm::mat4 orthoMatrix, Sunlight * light, int imageIndex, Camera * camera, ShadowMaps * shadowMaps, int frameBufferId)
{
vertexUniformBuffer.MVP = orthoMatrix;
vsUBO->Update(vulkan->GetVulkanDevice(), &vertexUniformBuffer, sizeof(vertexUniformBuffer));
fragmentUniformBuffer.lightDirection = light->GetLightDirection();
fragmentUniformBuffer.imageIndex = imageIndex;
fragmentUniformBuffer.cameraPosition = camera->GetPosition();
fragmentUniformBuffer.lightStrength = light->GetLightStrength();
for (int i = 0; i < SHADOW_CASCADE_COUNT; i++)
fragmentUniformBuffer.lightViewMatrix[i] = shadowMaps->GetLightViewProj(i);
fsUBO->Update(vulkan->GetVulkanDevice(), &fragmentUniformBuffer, sizeof(fragmentUniformBuffer));
drawCmdBuffers[frameBufferId]->BeginRecordingSecondary(vulkan->GetForwardRenderpass()->GetRenderpass(), vulkan->GetVulkanSwapchain()->GetFramebuffer((int)frameBufferId));
vulkan->InitViewportAndScissors(drawCmdBuffers[frameBufferId], (float)gSettings->GetWindowWidth(), (float)gSettings->GetWindowHeight(),
(uint32_t)gSettings->GetWindowWidth(), (uint32_t)gSettings->GetWindowHeight());
vulkanPipeline->SetActive(drawCmdBuffers[frameBufferId]);
VkDeviceSize offsets[1] = { 0 };
vkCmdBindVertexBuffers(drawCmdBuffers[frameBufferId]->GetCommandBuffer(), 0, 1, vertexBuffer->GetBuffer(), offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[frameBufferId]->GetCommandBuffer(), *indexBuffer->GetBuffer(), 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(drawCmdBuffers[frameBufferId]->GetCommandBuffer(), indexCount, 1, 0, 0, 0);
drawCmdBuffers[frameBufferId]->EndRecording();
drawCmdBuffers[frameBufferId]->ExecuteSecondary(commandBuffer);
} |
RenderDummy::RenderDummy();
RenderDummy::~RenderDummy();
void RenderDummy::Unload(VulkanInterface * vulkan);
| d6d8e96c9036c415eecd2f07bc5d7333da8401f7b1a7f4fcbc2d2097ab49a43c | 1,800 |