void LComponent::luserTriedToCloseWindow() {
if (child)
callback("userTriedToCloseWindow");
}
CONDITION
SRV_CStoreResponse(DUL_ASSOCIATIONKEY ** association,
DUL_PRESENTATIONCONTEXT * ctx,
MSG_C_STORE_REQ ** storeRequest, MSG_C_STORE_RESP * storeReply,
char *fileName, SRV_C_STORE_RESP_CALLBACK * callback,
void *callbackCtx,
char *dirName)
{
int
fd,
done;
unsigned long
total,
estimatedSize,
nextCallback;
unsigned short
sendStatus = 0x0000;
DUL_PDV
pdv;
CONDITION
cond;
DCM_OBJECT
* object;
DCM_FILE_META fileMeta;
int storeAsPart10 = 0;
char* paramValue;
storeReply->messageIDRespondedTo = (*storeRequest)->messageID;
storeReply->type = MSG_K_C_STORE_RESP;
(void) strcpy(storeReply->classUID, (*storeRequest)->classUID);
(void) strcpy(storeReply->instanceUID, (*storeRequest)->instanceUID);
storeReply->conditionalFields = MSG_K_C_STORERESP_CLASSUID |
MSG_K_C_STORERESP_INSTANCEUID;
storeReply->dataSetType = DCM_CMDDATANULL;
if (strlen(fileName) == 0)
{
fd = -1;
}
else
{
#ifdef _MSC_VER
fd = _open(fileName,
O_CREAT | O_WRONLY | O_TRUNC | O_BINARY,
_S_IREAD | _S_IWRITE);
#else
fd = open(fileName, O_CREAT | O_WRONLY | O_TRUNC, 0666);
#endif
if (fd < 0)
{
(void) COND_PushCondition(SRV_FILECREATEFAILED,
SRV_Message(SRV_FILECREATEFAILED), fileName,
"SRV_CStoreResponse");
}
}
if (strcmp(ctx->acceptedTransferSyntax, DICOM_TRANSFERLITTLEENDIAN) != 0)
{
storeAsPart10 = 1;
}
else
{
paramValue = UTL_GetConfigParameter("STORAGE/PART10FLAG");
if (paramValue != NULL)
{
if (strcmp(paramValue, "1") == 0)
{
storeAsPart10 = 1;
}
}
}
if ((storeAsPart10 == 1) && (fd > 0))
{
int localStatus = 0;
memset(&fileMeta, 0, sizeof(fileMeta));
setFileMeta(&fileMeta, *storeRequest, ctx->acceptedTransferSyntax);
localStatus = writePart10MetaHeader(fd, &fileMeta);
if (localStatus != 0)
fd = -1;
}
if (fd < 0)
{
sendStatus = MSG_K_C_STORE_OUTOFRESOURCES;
storeReply->conditionalFields |= MSG_K_C_STORERESP_ERRORCOMMENT;
strcpy(storeReply->errorComment,
"Storage Service unable to create local file");
}
done = 0;
total = 0;
estimatedSize = genericImageSize((*storeRequest)->classUID);
nextCallback = estimatedSize / 10;
while (!done)
{
cond = SRVPRV_ReadNextPDV(association, DUL_BLOCK, 0, &pdv);
if (cond != SRV_NORMAL)
{
(void) MSG_Free((void **) storeRequest);
return COND_PushCondition(SRV_RESPONSEFAILED,
SRV_Message(SRV_RESPONSEFAILED), "SRV_CStoreResponse");
}
if (pdv.pdvType != DUL_DATASETPDV)
{
(void) MSG_Free((void **) storeRequest);
return COND_PushCondition(SRV_UNEXPECTEDPDVTYPE,
SRV_Message(SRV_UNEXPECTEDPDVTYPE), (int) pdv.pdvType,
"SRV_CStoreResponse");
}
if (sendStatus == 0)
{
if (write(fd, pdv.data, pdv.fragmentLength) !=
(int) pdv.fragmentLength)
sendStatus = MSG_K_C_STORE_OUTOFRESOURCES;
}
total += pdv.fragmentLength;
if (pdv.lastPDV)
done++;
if (total > nextCallback)
{
cond = callback(*storeRequest, NULL, total, estimatedSize, NULL, callbackCtx, ctx);
if (cond != SRV_NORMAL)
{
(void) MSG_Free((void **) storeRequest);
return COND_PushCondition(SRV_RESPONSEFAILED,
SRV_Message(SRV_RESPONSEFAILED), "SRV_CStoreResponse");
}
nextCallback += estimatedSize / 10;
}
}
if (fd >= 0)
(void) close(fd);
storeReply->status = sendStatus;
if (sendStatus == 0x0000)
{
unsigned long options = DCM_ORDERLITTLEENDIAN;
if (storeAsPart10 == 1)
options = DCM_PART10FILE;
cond = DCM_OpenFile(fileName, options, &object);
if (cond != DCM_NORMAL)
{
(void) MSG_Free((void **) storeRequest);
return COND_PushCondition(SRV_RESPONSEFAILED,
SRV_Message(SRV_RESPONSEFAILED), "SRV_CStoreResponse");
}
cond = callback(*storeRequest, storeReply, total, estimatedSize, &object,
callbackCtx, ctx);
if (cond != SRV_NORMAL)
{
(void) DCM_CloseObject(&object);
return COND_PushCondition(SRV_RESPONSEFAILED,
SRV_Message(SRV_RESPONSEFAILED), "SRV_CStoreResponse");
}
(void) DCM_CloseObject(&object);
}
(void) MSG_Free((void **) storeRequest);
cond = MSG_BuildCommand(storeReply, &object);
if (cond != MSG_NORMAL)
return COND_PushCondition(SRV_OBJECTBUILDFAILED,
SRV_Message(SRV_OBJECTBUILDFAILED), "STORE Request",
"SRV_CStoreResponse");
cond = SRV_SendCommand(association, ctx, &object);
(void) DCM_CloseObject(&object);
if (cond != SRV_NORMAL)
return COND_PushCondition(SRV_RESPONSEFAILED,
SRV_Message(SRV_RESPONSEFAILED), "SRV_CStoreResponse");
return SRV_NORMAL;
}
static struct mailstream_ssl_data * ssl_data_new(int fd, time_t timeout,
void (* callback)(struct mailstream_ssl_context * ssl_context, void * cb_data), void * cb_data)
{
struct mailstream_ssl_data * ssl_data;
gnutls_session session;
struct mailstream_cancel * cancel;
gnutls_certificate_credentials_t xcred;
int r;
struct mailstream_ssl_context * ssl_context = NULL;
unsigned int timeout_value;
mailstream_ssl_init();
if (gnutls_certificate_allocate_credentials (&xcred) != 0)
return NULL;
r = gnutls_init(&session, GNUTLS_CLIENT);
if (session == NULL || r != 0)
return NULL;
if (callback != NULL) {
ssl_context = mailstream_ssl_context_new(session, fd);
callback(ssl_context, cb_data);
}
gnutls_session_set_ptr(session, ssl_context);
gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE, xcred);
#if GNUTLS_VERSION_NUMBER <= 0x020c00
gnutls_certificate_client_set_retrieve_function(xcred, mailstream_gnutls_client_cert_cb);
#else
gnutls_certificate_set_retrieve_function(xcred, mailstream_gnutls_client_cert_cb);
#endif
gnutls_set_default_priority(session);
gnutls_priority_set_direct(session, "NORMAL", NULL);
gnutls_record_disable_padding(session);
gnutls_dh_set_prime_bits(session, 512);
gnutls_transport_set_ptr(session, (gnutls_transport_ptr) fd);
/* lower limits on server key length restriction */
gnutls_dh_set_prime_bits(session, 512);
if (timeout == 0) {
timeout_value = mailstream_network_delay.tv_sec * 1000 + mailstream_network_delay.tv_usec / 1000;
}
else {
timeout_value = timeout;
}
#if GNUTLS_VERSION_NUMBER >= 0x030100
gnutls_handshake_set_timeout(session, timeout_value);
#endif
do {
r = gnutls_handshake(session);
} while (r == GNUTLS_E_AGAIN || r == GNUTLS_E_INTERRUPTED);
if (r < 0) {
gnutls_perror(r);
goto free_ssl_conn;
}
cancel = mailstream_cancel_new();
if (cancel == NULL)
goto free_ssl_conn;
r = mailstream_prepare_fd(fd);
if (r < 0)
goto free_cancel;
ssl_data = malloc(sizeof(* ssl_data));
if (ssl_data == NULL)
goto err;
ssl_data->fd = fd;
ssl_data->session = session;
ssl_data->xcred = xcred;
ssl_data->cancel = cancel;
mailstream_ssl_context_free(ssl_context);
return ssl_data;
free_cancel:
mailstream_cancel_free(cancel);
free_ssl_conn:
gnutls_certificate_free_credentials(xcred);
mailstream_ssl_context_free(ssl_context);
gnutls_deinit(session);
err:
return NULL;
}
// ================= MEMBER FUNCTIONS =======================
//
// ----------------------------------------------------------
// CFlashLite21LauncherAppUi::ConstructL()
//
// ----------------------------------------------------------
//
void CFlashLite21LauncherAppUi::ConstructL()
{
BaseConstructL();
//timer
iWaitTimer = CPeriodic::NewL( KWaitCallBackPriority );
TThreadId id;
RApaLsSession ls;
User::LeaveIfError(ls.Connect());
TApaAppInfo appinfo;
TInt KError = ls.GetAppInfo(appinfo, KUidFlash21);
CleanupClosePushL(ls);
if(KError == KErrNone)
{
//Search for open player
TFileName fnAppPath = appinfo.iFullName;
TApaTaskList taskList( CEikonEnv::Static()->WsSession() );
TApaTask task = taskList.FindApp( KUidFlash21 );
if(task.Exists()) //If player is already running
{
TInt err = task.SwitchOpenFile( KLitSwfFileToLaunch );
if(err == KErrNone)
{
//everything is fine
} else
{
//any error
}
task.BringToForeground();
}
else
{
if(KError == KErrNone) //the player is not running so we launch it
{
TInt result = ls.StartDocument(fnAppPath,id);
if (result!=KErrNone)
{
//any error
}
else
{
if ( iWaitTimer->IsActive())
{
iWaitTimer->Cancel();
}
TCallBack callback( WaitTimerCallbackL, this );
iWaitTimer->Start( ( TTimeIntervalMicroSeconds32 ) KMaxWaitTime,
( TTimeIntervalMicroSeconds32 ) KMaxWaitTime,
callback );
}
CleanupStack::PopAndDestroy(); // Destroy cmd
}
}
}
else
{
//FlashPlayer not installed
}
/*iAppContainer = new (ELeave) CFlashLite21LauncherContainer;
iAppContainer->SetMopParent( this );
iAppContainer->ConstructL( ClientRect() );
AddToStackL( iAppContainer );*/
}
void SceneIntersection::Update()
{
ssbo->ClearBuffer();
computeShader->Use();
auto rezolution = gameFBO->GetResolution();
auto camera = Manager::GetScene()->GetActiveCamera();
auto cameraPos = camera->transform->GetWorldPosition();
auto planePos = cameraPos - camera->transform->GetLocalOZVector() * 3.0f;
auto direction = -camera->transform->GetLocalOZVector();
glUniform3f(plane_direction, direction.x, direction.y, direction.z);
glUniform1f(sphere_size, sphereRadius);
gameFBO->SendResolution(computeShader);
camera->BindPosition(computeShader->loc_eye_pos);
ssbo->BindBuffer(0);
glBindImageTexture(0, visualization->GetTextureID(), 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R8UI);
glBindImageTexture(1, gameFBO->GetTextureID(3), 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
glBindImageTexture(2, Manager::GetPicker()->FBO->GetTextureID(0), 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
glBindImageTexture(3, gameFBO->GetTextureID(0), 0, GL_FALSE, 0, GL_READ_WRITE, GL_RGBA32F);
OpenGL::DispatchCompute(rezolution.x, rezolution.y, 1, 32);
ssbo->ReadBuffer();
// Compute Virtual 3D position - average of 3D points intersected by the sphere/plane for an object
auto size = ssbo->GetSize();
auto values = ssbo->GetBuffer();
// Used for computing world position from view position
//auto invView = glm::inverse(camera->GetViewMatrix());
centerPoints.clear();
objects.clear();
for (uint i = 0; i < size; i++) {
if (values[i].w) {
glm::vec4 averageViewSpacePos = glm::vec4(values[i]) / (float(1000 * values[i].w));
// Compute world position from view position
// the 4th component needs to be set to 1 otherwise the mutiplication will yield a wrong answer
//averageViewSpacePos.w = 1;
//glm::vec4 worldPos = invView * averageViewSpacePos;
//worldPos.w = float(i);
averageViewSpacePos.w = float(i);
centerPoints.push_back(averageViewSpacePos);
}
}
// ------------------------------------------------------------------------
// Get Objects and asign virtual camera space center position
if (centerPoints.size()) {
objects.reserve(centerPoints.size());
for (auto const &pos : centerPoints)
{
auto obj = Manager::GetColor()->GetObjectByID((unsigned int)pos.w);
auto source = dynamic_cast<CSound3DSource*>(obj);
if (source)
{
source->SetVirtualCameraSpacePosition(glm::vec3(pos));
objects.push_back(source);
}
}
}
for (auto callback : callbacks) {
callback(objects);
}
}
boolean walkPath(char *filepath, SdFile& parentDir,
boolean (*callback)(SdFile& parentDir,
char *filePathComponent,
boolean isLastComponent,
void *object),
void *object = NULL) {
/*
When given a file path (and parent directory--normally root),
this function traverses the directories in the path and at each
level calls the supplied callback function while also providing
the supplied object for context if required.
e.g. given the path '/foo/bar/baz'
the callback would be called at the equivalent of
'/foo', '/foo/bar' and '/foo/bar/baz'.
The implementation swaps between two different directory/file
handles as it traverses the directories and does not use recursion
in an attempt to use memory efficiently.
If a callback wishes to stop the directory traversal it should
return false--in this case the function will stop the traversal,
tidy up and return false.
If a directory path doesn't exist at some point this function will
also return false and not subsequently call the callback.
If a directory path specified is complete, valid and the callback
did not indicate the traversal should be interrupted then this
function will return true.
*/
SdFile subfile1;
SdFile subfile2;
char buffer[PATH_COMPONENT_BUFFER_LEN];
unsigned int offset = 0;
SdFile *p_parent;
SdFile *p_child;
SdFile *p_tmp_sdfile;
p_child = &subfile1;
p_parent = &parentDir;
while (true) {
boolean moreComponents = getNextPathComponent(filepath, &offset, buffer);
boolean shouldContinue = callback((*p_parent), buffer, !moreComponents, object);
if (!shouldContinue) {
// TODO: Don't repeat this code?
// If it's one we've created then we
// don't need the parent handle anymore.
if (p_parent != &parentDir) {
(*p_parent).close();
}
return false;
}
if (!moreComponents) {
break;
}
boolean exists = (*p_child).open(*p_parent, buffer, O_RDONLY);
// If it's one we've created then we
// don't need the parent handle anymore.
if (p_parent != &parentDir) {
(*p_parent).close();
}
// Handle case when it doesn't exist and we can't continue...
if (exists) {
// We alternate between two file handles as we go down
// the path.
if (p_parent == &parentDir) {
p_parent = &subfile2;
}
p_tmp_sdfile = p_parent;
p_parent = p_child;
p_child = p_tmp_sdfile;
} else {
return false;
}
}
if (p_parent != &parentDir) {
(*p_parent).close(); // TODO: Return/ handle different?
}
return true;
}
CONDITION
TBL_SelectTable(TBL_HANDLE ** handle, const TBL_CRITERIA * criteriaList,
TBL_FIELD * fieldList, long *count, CONDITION(*callback) (), void *ctx,
const char* tableName)
{
TBL_CONTEXT* tc;
TBL_FIELD* fp;
char tabcol[100];
char* dbName;
int i;
int ret;
int FoundTextorBinary;
int foundit;
char selectCommand[2048];
long realcount;
long * lp;
PGresult* res;
PGconn* conn;
int nTuples;
#ifdef CTN_USE_THREADS
THR_ObtainMutex(FAC_TBL);
#endif
tc = G_ContextHead;
foundit = 0;
while (tc != (TBL_CONTEXT *) NULL) {
if (tc == (TBL_CONTEXT *) (*handle)) {
dbName = tc->databaseName;
/*tableName = tc->tableName;*/
conn = (PGconn*)tc->dbSpecific;
foundit = 1;
break;
}
tc = tc->next;
}
if (!foundit) {
#ifdef CTN_USE_THREADS
THR_ReleaseMutex(FAC_TBL);
#endif
return COND_PushCondition(TBL_ERROR(TBL_BADHANDLE), "TBL_Select");
}
strcpy(selectCommand, "SELECT ");
addFieldNames(fieldList, selectCommand);
strcat(selectCommand, " FROM " );
strcat(selectCommand, tableName);
if ((criteriaList != (TBL_CRITERIA *) NULL) && (criteriaList->FieldName != 0)) {
strcat(selectCommand, " WHERE ");
addCriteria(criteriaList, selectCommand);
}
strcat(selectCommand, ";" );
if (count != (long *) NULL)
lp = count;
else
lp = &realcount;
*lp = 0;
res = PQexec(conn, selectCommand);
if (PQresultStatus(res) != PGRES_TUPLES_OK) {
fprintf(stderr, PQresultErrorMessage(res));
fprintf(stderr, "<%s>\n", selectCommand);
exit(1);
}
nTuples = PQntuples(res);
for (i = 0; i < nTuples; i++) {
(*lp)++;
extractFieldResults(res, i, fieldList);
if (callback != NULL) {
if (callback(fieldList, *lp, ctx) != TBL_NORMAL) {
PQclear(res);
#ifdef CTN_USE_THREADS
THR_ReleaseMutex(FAC_TBL);
#endif
return COND_PushCondition(TBL_ERROR(TBL_EARLYEXIT), "TBL_Select");
}
}
}
PQclear(res);
#ifdef CTN_USE_THREADS
THR_ReleaseMutex(FAC_TBL);
#endif
return TBL_NORMAL;
}
void LComponent::lhandleCommandMessage( int commandId ) {
if (child)
callback("handleCommandMessage");
}
void LComponent::lfocusGained( Component::FocusChangeType cause ) {
if (child)
callback("focusGained");
}
void LComponent::lvisibilityChanged() {
if (child) {
callback("visibilityChanged", 1);
LUA::checkAndGetBoolean(-1, false);
}
}
void LComponent::linputAttemptWhenModal() {
if (child)
callback("inputAttemptWhenModal");
}
void LComponent::lparentSizeChanged() {
if (child)
callback("parentSizeChanged");
}
void LComponent::lbroughtToFront() {
if (child)
callback("broughtToFront");
}
void LComponent::lmodifierKeysChanged( const ModifierKeys& modifiers ) {
if (child)
callback("modifierKeysChanged");
}
void doCallback(int status, int data1, int data2) {
if (callback != NULL){
callback(status, data1, data2);
}
}
void LComponent::lpaintOverChildren( Graphics& g ) {
if (child)
callback("paintOverChildren");
}
virtual bool execute ( IAgent* agent, DWORD sessionId )
{
net_task_callback callback( agent, sessionId );
return execution_impl.execute( callback ) && !callback.break_all( );
};
void LComponent::lmoved() {
if (child)
callback("moved");
}
/* TBL_Layout
**
** Purpose:
** This function returns the columns and types of a particular
** table specified by handle.
**
** Parameter Dictionary:
** char *databaseName: The name of the database to use.
** char *tableName: The name of the table to access.
** CONDITION (*callback)(): The callback function invoked whenever
** a new record is retreived from the database. It is
** invoked with parameters as described below.
** void *ctx: Ancillary data passed through to the callback function
** and untouched by this routine.
**
** Return Values:
** TBL_NORMAL: normal termination.
** TBL_NOCALLBACK: No callback function was specified.
** TBL_DBNOEXIST: The database specified does not exist.
** TBL_TBLNOEXIST: The table specified did not exist in the correct
** internal database table...this may indicate some sort
** of consistency problem withing the database.
** TBL_NOCOLUMNS: The table specified contains no columnns.
** TBL_EARLYEXIT: The callback routine returned something other than
** TBL_NORMAL which caused this routine to cancel the remainder
** of the database operation and return early.
**
** Notes:
** It is an error to specify a null callback function.
**
** Algorithm:
** As each column is retrieved from the specified table, the
** callback function is invoked as follows:
**
** callback(fieldList *fieldList, void *ctx)
**
** fieldList contains the field name and the type of the column from
** the table specified.
** ctx contains any additional information the user originally passed
** to this layout function. If callback returns any value other
** than TBL_NORMAL, it is assumed that this function should terminate
** (i.e. cancel the current db operation), and return an abnormal
** termination message (TBL_EARLYEXIT) to the routine which
** originally invoked TBL_Layout.
*/
CONDITION
TBL_Layout(char *databaseName, char *tableName,
CONDITION(*callback) (), void *ctx) {
TBL_FIELD field;
int i;
char descbuf[512];
TBL_HANDLE* handle;
TBL_CONTEXT* tc;
CONDITION cond;
PGresult *res;
PGconn* conn;
int nTuples;
char lcTable[512];
if (callback == NULL) {
return COND_PushCondition(TBL_ERROR(TBL_NOCALLBACK), "TBL_Layout");
}
remapLower(tableName, lcTable);
cond = TBL_Open(databaseName, tableName, &handle);
if (cond != TBL_NORMAL)
return cond;
tc = (TBL_CONTEXT*)handle;
conn = (PGconn*)tc->dbSpecific;
strcpy(descbuf, "SELECT a.attname, t.typname, a.attlen ");
strcat(descbuf, "FROM pg_class c, pg_attribute a, pg_type t ");
strcat(descbuf, "WHERE c.relname = '");
strcat(descbuf, lcTable);
strcat(descbuf, "'");
strcat(descbuf, " and a.attnum > 0 ");
strcat(descbuf, " and a.attrelid = c.oid ");
strcat(descbuf, " and a.atttypid = t.oid ");
res = PQexec(conn, descbuf);
if (PQresultStatus(res) != PGRES_TUPLES_OK) {
fprintf(stderr, PQresultErrorMessage(res));
exit(1);
}
nTuples = PQntuples(res);
for (i = 0; i < nTuples; i++) {
char *c;
field.FieldName = PQgetvalue(res, i, 0);
field.Value.AllocatedSize = atoi(PQgetvalue(res, i, 2));
field.Value.Type = TBL_SIGNED4;
c = PQgetvalue(res, i, 1);
if (strcmp(c, "bpchar") == 0)
field.Value.Type = TBL_STRING;
else if (strcmp(c, "int4") == 0)
field.Value.Type = TBL_SIGNED4;
else if (strcmp(c, "float8") == 0)
field.Value.Type = TBL_FLOAT8;
else
printf ("%s\n", c);
if (callback != NULL) {
if (callback(&field, ctx) != TBL_NORMAL) {
return COND_PushCondition(TBL_ERROR(TBL_EARLYEXIT), "TBL_Layout");
}
}
PQclear(res);
}
return TBL_NORMAL;
}
void LComponent::lchildBoundsChanged( Component* child ) {
if (child)
callback("childBoundsChanged");
}
void Button::call()
{
callback();
}
void LComponent::lfocusLost( Component::FocusChangeType cause ) {
if (child)
callback("focusLost");
}
void GLUI_EditText::disactivate( void )
{
int new_int_val;
float new_float_val;
active = false;
if ( NOT glui )
return;
if ( debug )
dump( stdout, "-> DISACTIVATE" );
sel_start = sel_end = insertion_pt = -1;
/***** Retrieve the current value from the text *****/
/***** The live variable will be updated by set_text() ****/
if ( data_type == GLUI_EDITTEXT_FLOAT ) {
if ( text[0] == '\0' ) /* zero-length string - make it "0.0" */
strcpy( text, "0.0" );
new_float_val = atof( text );
set_float_val( new_float_val );
}
else if ( data_type == GLUI_EDITTEXT_INT ) {
if ( text[0] == '\0' ) /* zero-length string - make it "0" */
strcpy( text, "0" );
new_int_val = atoi( text );
set_int_val( new_int_val );
}
else
if ( data_type == GLUI_EDITTEXT_TEXT ) {
set_text(text); /* This will force callbacks and gfx refresh */
}
update_substring_bounds();
/******** redraw text without insertion point ***********/
translate_and_draw_front();
/***** Now do callbacks if value changed ******/
if ( strcmp( orig_text, text ) != 0 ) {
this->execute_callback();
if ( 0 ) {
/* THE CODE BELOW IS FROM WHEN SPINNER ALSO MAINTAINED CALLBACKS */
if ( spinner == NULL ) { /** Are we independent of a spinner? **/
if ( callback ) {
callback( this->user_id );
}
}
else { /* We're attached to a spinner */
spinner->do_callbacks(); /* Let the spinner do the callback stuff */
}
}
}
if ( debug )
dump( stdout, "<- DISACTIVATE" );
}
explicit actor(F callback)
: thread{[&, this] { callback(*this); }}
, queue{} { }
CONDITION
SRV_CStoreRequest(DUL_ASSOCIATIONKEY ** association,
DUL_ASSOCIATESERVICEPARAMETERS * params,
MSG_C_STORE_REQ * storeRequest, MSG_C_STORE_RESP * storeResponse,
SRV_C_STORE_REQ_CALLBACK * callback, void *callbackCtx,
char *dirName)
{
DCM_OBJECT
* commandObject, /* Handle for a command object */
*dataSetObject; /* Handle for a Data Set object */
CONDITION
cond; /* Return value from function calls */
DUL_PRESENTATIONCONTEXT
* presentationCtx; /* Presentation context for this service */
DUL_PRESENTATIONCONTEXTID
ctxID;
void
*message;
MSG_TYPE
messageType;
unsigned long
objectSize;
unsigned short
command;
STORAGE_CTX
localCtx;
MSG_C_STORE_RESP
* response;
localCtx.callback = callback;
localCtx.storeRequest = storeRequest;
localCtx.storeResponse = NULL;
localCtx.userCtx = callbackCtx;
if (callback == NULL)
return COND_PushCondition(SRV_NOCALLBACK,
SRV_Message(SRV_NOCALLBACK), "SRV_CStoreRequest");
if (storeRequest->type != MSG_K_C_STORE_REQ)
return COND_PushCondition(SRV_ILLEGALPARAMETER,
SRV_Message(SRV_ILLEGALPARAMETER), "type", "STORE Request",
"SRV_CStoreRequest");
if (storeRequest->dataSetType == DCM_CMDDATANULL)
return COND_PushCondition(SRV_ILLEGALPARAMETER,
SRV_Message(SRV_ILLEGALPARAMETER), "dataSetType", "STORE Request",
"SRV_CStoreRequest");
presentationCtx = SRVPRV_PresentationContext(params,
storeRequest->classUID);
if (presentationCtx == NULL)
{
return COND_PushCondition(SRV_NOSERVICEINASSOCIATION,
SRV_Message(SRV_NOSERVICEINASSOCIATION), storeRequest->classUID,
"SRV_CStoreRequest");
}
cond = MSG_BuildCommand(storeRequest, &commandObject);
if (cond != MSG_NORMAL)
return COND_PushCondition(SRV_OBJECTBUILDFAILED,
SRV_Message(SRV_OBJECTBUILDFAILED), "STORE Request",
"SRV_CStoreRequest");
dataSetObject = storeRequest->dataSet;
if (dataSetObject == NULL)
{
cond = DCM_OpenFile(storeRequest->fileName, DCM_ORDERLITTLEENDIAN,
&dataSetObject);
if (cond != DCM_NORMAL)
return COND_PushCondition(SRV_REQUESTFAILED,
SRV_Message(SRV_REQUESTFAILED), "SRV_CStoreRequest");
}
cond = DCM_GetObjectSize(&dataSetObject, &objectSize);
if (cond != DCM_NORMAL)
return COND_PushCondition(SRV_REQUESTFAILED,
SRV_Message(SRV_REQUESTFAILED), "SRV_CStoreRequest");
cond = SRV_SendCommand(association, presentationCtx, &commandObject);
(void) DCM_CloseObject(&commandObject);
if (cond != SRV_NORMAL)
return COND_PushCondition(SRV_REQUESTFAILED,
SRV_Message(SRV_REQUESTFAILED), "SRV_CStoreRequest");
cond = callback(storeRequest, NULL, 0, objectSize, callbackCtx);
if (cond != SRV_NORMAL)
return COND_PushCondition(SRV_REQUESTFAILED,
SRV_Message(SRV_REQUESTFAILED), "SRV_CStoreRequest");
cond = SRV_SendDataSet(association, presentationCtx, &dataSetObject,
localCallback, &localCtx, objectSize);
if (storeRequest->dataSet == NULL)
(void) DCM_CloseObject(&dataSetObject);
if (cond != SRV_NORMAL)
return COND_PushCondition(SRV_REQUESTFAILED,
SRV_Message(SRV_REQUESTFAILED), "SRV_CStoreRequest");
cond = SRV_ReceiveCommand(association, params, DUL_BLOCK, 0, &ctxID,
&command, &messageType, &message);
if (cond != SRV_NORMAL)
{
return COND_PushCondition(SRV_REQUESTFAILED,
SRV_Message(SRV_REQUESTFAILED), "SRV_CStoreRequest");
}
if (messageType != MSG_K_C_STORE_RESP)
{
(void) MSG_Free(&message);
return COND_PushCondition(SRV_UNEXPECTEDCOMMAND,
SRV_Message(SRV_UNEXPECTEDCOMMAND), (int) command,
"SRV_CStoreRequest");
}
response = (MSG_C_STORE_RESP *) message;
if (storeResponse != NULL)
*storeResponse = *response;
cond = callback(storeRequest, response, objectSize, objectSize,
callbackCtx);
(void) MSG_Free(&message);
if (cond != SRV_NORMAL)
return COND_PushCondition(SRV_CALLBACKABORTEDSERVICE,
SRV_Message(SRV_CALLBACKABORTEDSERVICE), "SRV_CStoreRequest");
return SRV_NORMAL;
}
/**
****************************************************************************************
* @brief Enable sleep mode
* @param[in] mode sleep mode
* @param[in] iconfig wakeup interrupt config
* @param[in] callback callback after wakeup
* @description
* This function is used to set MCU into sleep mode, before enter sleep, wakeup source should be set.
*****************************************************************************************
*/
void enter_sleep(enum SLEEP_MODE mode, uint32_t iconfig, void (*callback)(void))
{
if (mode == SLEEP_CPU_CLK_OFF) {
// --------------------------------------------
// cpu clock disable
// --------------------------------------------
// Ensure we use deep SLEEP - SLEEPDEEP should be set
// SCR[2] = SLEEPDEEP
SCB->SCR |= (1UL << 2);
// set pd state to deep gating
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_PD_STATE|SYSCON_MASK_PMUENABLE, MASK_DISABLE);
GLOBAL_INT_DISABLE();
#if SLEEP_CONFIG_EN == TRUE
NVIC->ISER[0] = iconfig;
#endif
// Wait For Interrupt
__WFI(); // Enter sleep mode
// Wakeup when interrupt is triggered
GLOBAL_INT_RESTORE();
// TODO
}
else if (mode == SLEEP_NORMAL) {
#if QN_LOW_POWER_MODE_EN==TRUE
enter_low_power_mode(0);
// --------------------------------------------
// cpu clock disable
// --------------------------------------------
// Ensure we use deep SLEEP - SLEEPDEEP should be set
// SCR[2] = SLEEPDEEP
SCB->SCR |= (1UL << 2);
#else
// --------------------------------------------
// sleep
// --------------------------------------------
#ifdef BLE_PRJ
// Save configuration before power down
save_ble_setting();
#endif
#if (defined(QN_9020_B1) && QN_PMU_VOLTAGE)
// Switch off REF PLL power
syscon_SetPGCR1WithMask(QN_SYSCON, SYSCON_MASK_DIS_REF_PLL, MASK_ENABLE);
#endif
// switch to internal 20MHz
syscon_SetCMDCRWithMask(QN_SYSCON, SYSCON_MASK_CLK_MUX, CLK_INT_20M<<SYSCON_POS_CLK_MUX);
// power down all module in sleep except 32K and retention memory
syscon_SetPGCR0WithMask(QN_SYSCON, sleep_env.retention_modules|0x00000001, 0x00000001);
#if (defined(QN_9020_B0) && QN_PMU_VOLTAGE)
syscon_SetCMDCRWithMask(QN_SYSCON, SYSCON_MASK_AHB_DIV_BYPASS|SYSCON_MASK_AHB_DIVIDER,
(0xf<<SYSCON_POS_AHB_DIVIDER));
#endif
// Ensure we use deep SLEEP - SLEEPDEEP should be set
// SCR[2] = SLEEPDEEP
SCB->SCR |= (1UL << 2);
// set pd state to sleep
#if !QN_PMU_VOLTAGE
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_PD_STATE|SYSCON_MASK_DVDD12_PMU_SET|SYSCON_MASK_PMUENABLE, MASK_ENABLE);
#else
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_PD_STATE|SYSCON_MASK_PMUENABLE, MASK_ENABLE);
#endif
syscon_SetIvrefX32WithMask(QN_SYSCON, SYSCON_MASK_VREG12_A|SYSCON_MASK_VREG12_D|SYSCON_MASK_DVDD12_SW_EN,
(0x0 << SYSCON_POS_VREG12_A)|(0x0 << SYSCON_POS_VREG12_D));
#endif // QN_LOW_POWER_MODE_EN==TRUE
#if SLEEP_CONFIG_EN == TRUE
NVIC->ICPR[0] = 0x00000020; // clear OSC_EN pending flag
NVIC->ISER[0] = iconfig;
#endif
// Wait For Interrupt
__WFI(); // Enter sleep mode
// Wakeup when sleep timer, comparator or gpio is triggered
// Disable interrupt in the wakeup procedure.
NVIC->ICER[0] = iconfig;
#if QN_LOW_POWER_MODE_EN==TRUE
#ifdef BLE_PRJ
restore_from_low_power_mode(NULL);
#else
restore_from_low_power_mode(callback);
#endif
#else
// 1.2V
syscon_SetIvrefX32WithMask(QN_SYSCON, SYSCON_MASK_VREG12_A|SYSCON_MASK_VREG12_D|SYSCON_MASK_DVDD12_SW_EN,
(0x1 << SYSCON_POS_VREG12_A)|(0x0 << SYSCON_POS_VREG12_D)|SYSCON_MASK_DVDD12_SW_EN);
#if (defined(QN_9020_B0) && QN_PMU_VOLTAGE)
syscon_SetCMDCRWithMask(QN_SYSCON, SYSCON_MASK_AHB_DIV_BYPASS, MASK_ENABLE);
#endif
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_PD_STATE|SYSCON_MASK_DVDD12_PMU_SET, MASK_DISABLE);
#if SLEEP_CALLBACK_EN == TRUE
if (callback != NULL) {
callback();
}
#endif
#if (defined(QN_9020_B0) && QN_PMU_VOLTAGE)
syscon_set_ahb_clk(__AHB_CLK);
#endif
// 16MHz/32MHz XTAL is ready
while (!(syscon_GetBLESR(QN_SYSCON) & SYSCON_MASK_CLK_RDY))
{
// XTAL shall be ready before BLE wakeup
if(check_ble_wakeup())
{
// In this case XTAL wakeup duration is larger than setting.
// The parameter 'Oscillator wake-up time' in the NVDS should be revised.
#if (QN_DBG_INFO)
set_dbg_info(QN_DBG_INFO_XTAL_WAKEUP_DURATION);
#endif
}
}
syscon_SetCMDCRWithMask(QN_SYSCON, SYSCON_MASK_CLK_MUX, CLK_XTAL<<SYSCON_POS_CLK_MUX);
#endif // QN_LOW_POWER_MODE_EN==TRUE
#if ((defined(QN_9020_B2) || defined(QN_9020_B1)) && defined(BLE_PRJ))
sleep_post_process();
#endif
}
#if (QN_DEEP_SLEEP_EN)
else if (mode == SLEEP_DEEP) {
// --------------------------------------------
// deep sleep
// --------------------------------------------
#ifdef BLE_PRJ
// Save configuration before power down
save_ble_setting();
#endif
#if (defined(QN_9020_B1) && QN_PMU_VOLTAGE)
// Switch off REF PLL power
syscon_SetPGCR1WithMask(QN_SYSCON, SYSCON_MASK_DIS_REF_PLL, MASK_ENABLE);
#endif
// switch to internal 20MHz
syscon_SetCMDCRWithMask(QN_SYSCON, SYSCON_MASK_CLK_MUX, CLK_INT_20M<<SYSCON_POS_CLK_MUX);
sleep_env.deep_sleep = true;
// power down all module in deep sleep except retention memory
#if (defined(QN_9020_B2) || defined(QN_9020_B1))
syscon_SetPGCR0WithMask(QN_SYSCON, 0xF7FFFCFF, 0xFFFFFC01|~sleep_env.retention_modules);
#elif defined(QN_9020_B0)
syscon_SetPGCR0WithMask(QN_SYSCON, 0xFFFFFCFF, 0xFFFFFC01|~sleep_env.retention_modules);
#endif
#if (defined(QN_9020_B0) && QN_PMU_VOLTAGE)
syscon_SetCMDCRWithMask(QN_SYSCON, SYSCON_MASK_AHB_DIV_BYPASS|SYSCON_MASK_AHB_DIVIDER,
(0xf<<SYSCON_POS_AHB_DIVIDER));
#endif
// Ensure we use deep SLEEP - SLEEPDEEP should be set
// SCR[2] = SLEEPDEEP
SCB->SCR |= (1UL << 2);
// set pd state to sleep
#if !QN_PMU_VOLTAGE
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_PD_STATE|SYSCON_MASK_DVDD12_PMU_SET|SYSCON_MASK_PMUENABLE, MASK_ENABLE);
#else
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_PD_STATE|SYSCON_MASK_PMUENABLE, MASK_ENABLE);
#endif
syscon_SetIvrefX32WithMask(QN_SYSCON, SYSCON_MASK_VREG12_A|SYSCON_MASK_VREG12_D|SYSCON_MASK_DVDD12_SW_EN,
(0x0 << SYSCON_POS_VREG12_A)|(0x0 << SYSCON_POS_VREG12_D));
#if SLEEP_CONFIG_EN == TRUE
NVIC->ICPR[0] = 0x00000020; // clear OSC_EN pending flag
NVIC->ISER[0] = iconfig;
#endif
// Wait For Interrupt
__WFI(); // Enter sleep mode
// Wakeup when sleep timer, comparator or gpio is triggered
// Disable interrupt in the wakeup procedure.
NVIC->ICER[0] = iconfig;
// 1.2V
syscon_SetIvrefX32WithMask(QN_SYSCON, SYSCON_MASK_VREG12_A|SYSCON_MASK_VREG12_D|SYSCON_MASK_DVDD12_SW_EN,
(0x1 << SYSCON_POS_VREG12_A)|(0x0 << SYSCON_POS_VREG12_D)|SYSCON_MASK_DVDD12_SW_EN);
#if (defined(QN_9020_B0) && QN_PMU_VOLTAGE)
syscon_SetCMDCRWithMask(QN_SYSCON, SYSCON_MASK_AHB_DIV_BYPASS, MASK_ENABLE);
#endif
syscon_SetPGCR2WithMask(QN_SYSCON, SYSCON_MASK_PD_STATE|SYSCON_MASK_DVDD12_PMU_SET, MASK_DISABLE);
#if SLEEP_CALLBACK_EN == TRUE
if (callback != NULL) {
callback();
}
#endif
#if (defined(QN_9020_B0) && QN_PMU_VOLTAGE)
syscon_set_ahb_clk(__AHB_CLK);
#endif
// 16MHz/32MHz XTAL is ready
while (!(syscon_GetBLESR(QN_SYSCON) & SYSCON_MASK_CLK_RDY))
{
// XTAL shall be ready before BLE wakeup
if(check_ble_wakeup())
{
// In this case XTAL wakeup duration is larger than setting.
// The parameter 'Oscillator wake-up time' in the NVDS should be revised.
#if (QN_DBG_INFO)
set_dbg_info(QN_DBG_INFO_XTAL_WAKEUP_DURATION);
#endif
}
}
syscon_SetCMDCRWithMask(QN_SYSCON, SYSCON_MASK_CLK_MUX, CLK_XTAL<<SYSCON_POS_CLK_MUX);
#if ((defined(QN_9020_B2) || defined(QN_9020_B1)) && defined(BLE_PRJ))
sleep_post_process();
#endif
}
#endif // QN_DEEP_SLEEP_EN
}
static struct mailstream_ssl_data * ssl_data_new_full(int fd, time_t timeout,
SSL_METHOD * method, void (* callback)(struct mailstream_ssl_context * ssl_context, void * cb_data),
void * cb_data)
{
struct mailstream_ssl_data * ssl_data;
SSL * ssl_conn;
int r;
SSL_CTX * tmp_ctx;
struct mailstream_cancel * cancel;
struct mailstream_ssl_context * ssl_context = NULL;
mailstream_ssl_init();
tmp_ctx = SSL_CTX_new(method);
if (tmp_ctx == NULL)
goto err;
if (callback != NULL) {
ssl_context = mailstream_ssl_context_new(tmp_ctx, fd);
callback(ssl_context, cb_data);
}
SSL_CTX_set_app_data(tmp_ctx, ssl_context);
SSL_CTX_set_client_cert_cb(tmp_ctx, mailstream_openssl_client_cert_cb);
ssl_conn = (SSL *) SSL_new(tmp_ctx);
if (ssl_conn == NULL)
goto free_ctx;
if (SSL_set_fd(ssl_conn, fd) == 0)
goto free_ssl_conn;
again:
r = SSL_connect(ssl_conn);
switch(SSL_get_error(ssl_conn, r)) {
case SSL_ERROR_WANT_READ:
r = wait_SSL_connect(fd, 1, timeout);
if (r < 0)
goto free_ssl_conn;
else
goto again;
break;
case SSL_ERROR_WANT_WRITE:
r = wait_SSL_connect(fd, 0, timeout);
if (r < 0)
goto free_ssl_conn;
else
goto again;
break;
}
if (r <= 0)
goto free_ssl_conn;
cancel = mailstream_cancel_new();
if (cancel == NULL)
goto free_ssl_conn;
r = mailstream_prepare_fd(fd);
if (r < 0)
goto free_cancel;
ssl_data = malloc(sizeof(* ssl_data));
if (ssl_data == NULL)
goto free_cancel;
ssl_data->fd = fd;
ssl_data->ssl_conn = ssl_conn;
ssl_data->ssl_ctx = tmp_ctx;
ssl_data->cancel = cancel;
mailstream_ssl_context_free(ssl_context);
return ssl_data;
free_cancel:
mailstream_cancel_free(cancel);
free_ssl_conn:
SSL_free(ssl_conn);
free_ctx:
SSL_CTX_free(tmp_ctx);
mailstream_ssl_context_free(ssl_context);
err:
return NULL;
}
void mlt_vlog( void* service, int level, const char *fmt, va_list vl )
{
if ( callback ) callback( service, level, fmt, vl );
}
bool KX_ConstraintActuator::Update(double curtime, bool frame)
{
bool result = false;
bool bNegativeEvent = IsNegativeEvent();
RemoveAllEvents();
if (!bNegativeEvent) {
/* Constraint clamps the values to the specified range, with a sort of */
/* low-pass filtered time response, if the damp time is unequal to 0. */
/* Having to retrieve location/rotation and setting it afterwards may not */
/* be efficient enough... Something to look at later. */
KX_GameObject *obj = (KX_GameObject*) GetParent();
MT_Point3 position = obj->NodeGetWorldPosition();
MT_Point3 newposition;
MT_Vector3 normal, direction, refDirection;
MT_Matrix3x3 rotation = obj->NodeGetWorldOrientation();
MT_Scalar filter, newdistance, cosangle;
int axis, sign;
if (m_posDampTime) {
filter = m_posDampTime/(1.0f+m_posDampTime);
} else {
filter = 0.0f;
}
switch (m_locrot) {
case KX_ACT_CONSTRAINT_ORIX:
case KX_ACT_CONSTRAINT_ORIY:
case KX_ACT_CONSTRAINT_ORIZ:
switch (m_locrot) {
case KX_ACT_CONSTRAINT_ORIX:
direction[0] = rotation[0][0];
direction[1] = rotation[1][0];
direction[2] = rotation[2][0];
axis = 0;
break;
case KX_ACT_CONSTRAINT_ORIY:
direction[0] = rotation[0][1];
direction[1] = rotation[1][1];
direction[2] = rotation[2][1];
axis = 1;
break;
default:
direction[0] = rotation[0][2];
direction[1] = rotation[1][2];
direction[2] = rotation[2][2];
axis = 2;
break;
}
if ((m_maximumBound < (1.0f-FLT_EPSILON)) || (m_minimumBound < (1.0f-FLT_EPSILON))) {
// reference direction needs to be evaluated
// 1. get the cosine between current direction and target
cosangle = direction.dot(m_refDirVector);
if (cosangle >= (m_maximumBound-FLT_EPSILON) && cosangle <= (m_minimumBound+FLT_EPSILON)) {
// no change to do
result = true;
goto CHECK_TIME;
}
// 2. define a new reference direction
// compute local axis with reference direction as X and
// Y in direction X refDirection plane
MT_Vector3 zaxis = m_refDirVector.cross(direction);
if (MT_fuzzyZero2(zaxis.length2())) {
// direction and refDirection are identical,
// choose any other direction to define plane
if (direction[0] < 0.9999f)
zaxis = m_refDirVector.cross(MT_Vector3(1.0f,0.0f,0.0f));
else
zaxis = m_refDirVector.cross(MT_Vector3(0.0f,1.0f,0.0f));
}
MT_Vector3 yaxis = zaxis.cross(m_refDirVector);
yaxis.normalize();
if (cosangle > m_minimumBound) {
// angle is too close to reference direction,
// choose a new reference that is exactly at minimum angle
refDirection = m_minimumBound * m_refDirVector + m_minimumSine * yaxis;
} else {
// angle is too large, choose new reference direction at maximum angle
refDirection = m_maximumBound * m_refDirVector + m_maximumSine * yaxis;
}
} else {
refDirection = m_refDirVector;
}
// apply damping on the direction
direction = filter*direction + (1.0f-filter)*refDirection;
obj->AlignAxisToVect(direction, axis);
result = true;
goto CHECK_TIME;
case KX_ACT_CONSTRAINT_DIRPX:
case KX_ACT_CONSTRAINT_DIRPY:
case KX_ACT_CONSTRAINT_DIRPZ:
case KX_ACT_CONSTRAINT_DIRNX:
case KX_ACT_CONSTRAINT_DIRNY:
case KX_ACT_CONSTRAINT_DIRNZ:
switch (m_locrot) {
case KX_ACT_CONSTRAINT_DIRPX:
normal[0] = rotation[0][0];
normal[1] = rotation[1][0];
normal[2] = rotation[2][0];
axis = 0; // axis according to KX_GameObject::AlignAxisToVect()
sign = 0; // X axis will be parrallel to direction of ray
break;
case KX_ACT_CONSTRAINT_DIRPY:
normal[0] = rotation[0][1];
normal[1] = rotation[1][1];
normal[2] = rotation[2][1];
axis = 1;
sign = 0;
break;
case KX_ACT_CONSTRAINT_DIRPZ:
normal[0] = rotation[0][2];
normal[1] = rotation[1][2];
normal[2] = rotation[2][2];
axis = 2;
sign = 0;
break;
case KX_ACT_CONSTRAINT_DIRNX:
normal[0] = -rotation[0][0];
normal[1] = -rotation[1][0];
normal[2] = -rotation[2][0];
axis = 0;
sign = 1;
break;
case KX_ACT_CONSTRAINT_DIRNY:
normal[0] = -rotation[0][1];
normal[1] = -rotation[1][1];
normal[2] = -rotation[2][1];
axis = 1;
sign = 1;
break;
case KX_ACT_CONSTRAINT_DIRNZ:
normal[0] = -rotation[0][2];
normal[1] = -rotation[1][2];
normal[2] = -rotation[2][2];
axis = 2;
sign = 1;
break;
}
normal.normalize();
if (m_option & KX_ACT_CONSTRAINT_LOCAL) {
// direction of the ray is along the local axis
direction = normal;
} else {
switch (m_locrot) {
case KX_ACT_CONSTRAINT_DIRPX:
direction = MT_Vector3(1.0f,0.0f,0.0f);
break;
case KX_ACT_CONSTRAINT_DIRPY:
direction = MT_Vector3(0.0f,1.0f,0.0f);
break;
case KX_ACT_CONSTRAINT_DIRPZ:
direction = MT_Vector3(0.0f,0.0f,1.0f);
break;
case KX_ACT_CONSTRAINT_DIRNX:
direction = MT_Vector3(-1.0f,0.0f,0.0f);
break;
case KX_ACT_CONSTRAINT_DIRNY:
direction = MT_Vector3(0.0f,-1.0f,0.0f);
break;
case KX_ACT_CONSTRAINT_DIRNZ:
direction = MT_Vector3(0.0f,0.0f,-1.0f);
break;
}
}
{
MT_Point3 topoint = position + (m_maximumBound) * direction;
PHY_IPhysicsEnvironment* pe = KX_GetActiveScene()->GetPhysicsEnvironment();
PHY_IPhysicsController *spc = obj->GetPhysicsController();
if (!pe) {
std::cout << "WARNING: Constraint actuator " << GetName() << ": There is no physics environment!" << std::endl;
goto CHECK_TIME;
}
if (!spc) {
// the object is not physical, we probably want to avoid hitting its own parent
KX_GameObject *parent = obj->GetParent();
if (parent) {
spc = parent->GetPhysicsController();
}
}
KX_RayCast::Callback<KX_ConstraintActuator, void> callback(this,dynamic_cast<PHY_IPhysicsController*>(spc));
result = KX_RayCast::RayTest(pe, position, topoint, callback);
if (result) {
MT_Vector3 newnormal = callback.m_hitNormal;
// compute new position & orientation
if ((m_option & (KX_ACT_CONSTRAINT_NORMAL|KX_ACT_CONSTRAINT_DISTANCE)) == 0) {
// if none option is set, the actuator does nothing but detect ray
// (works like a sensor)
goto CHECK_TIME;
}
if (m_option & KX_ACT_CONSTRAINT_NORMAL) {
MT_Scalar rotFilter;
// apply damping on the direction
if (m_rotDampTime) {
rotFilter = m_rotDampTime/(1.0f+m_rotDampTime);
} else {
rotFilter = filter;
}
newnormal = rotFilter*normal - (1.0f-rotFilter)*newnormal;
obj->AlignAxisToVect((sign)?-newnormal:newnormal, axis);
if (m_option & KX_ACT_CONSTRAINT_LOCAL) {
direction = newnormal;
direction.normalize();
}
}
if (m_option & KX_ACT_CONSTRAINT_DISTANCE) {
if (m_posDampTime) {
newdistance = filter*(position-callback.m_hitPoint).length()+(1.0f-filter)*m_minimumBound;
} else {
newdistance = m_minimumBound;
}
// logically we should cancel the speed along the ray direction as we set the
// position along that axis
spc = obj->GetPhysicsController();
if (spc && spc->IsDynamic()) {
MT_Vector3 linV = spc->GetLinearVelocity();
// cancel the projection along the ray direction
MT_Scalar fallspeed = linV.dot(direction);
if (!MT_fuzzyZero(fallspeed))
spc->SetLinearVelocity(linV-fallspeed*direction,false);
}
} else {
newdistance = (position-callback.m_hitPoint).length();
}
newposition = callback.m_hitPoint-newdistance*direction;
} else if (m_option & KX_ACT_CONSTRAINT_PERMANENT) {
// no contact but still keep running
result = true;
goto CHECK_TIME;
}
}
break;
case KX_ACT_CONSTRAINT_FHPX:
case KX_ACT_CONSTRAINT_FHPY:
case KX_ACT_CONSTRAINT_FHPZ:
case KX_ACT_CONSTRAINT_FHNX:
case KX_ACT_CONSTRAINT_FHNY:
case KX_ACT_CONSTRAINT_FHNZ:
switch (m_locrot) {
case KX_ACT_CONSTRAINT_FHPX:
normal[0] = -rotation[0][0];
normal[1] = -rotation[1][0];
normal[2] = -rotation[2][0];
direction = MT_Vector3(1.0f,0.0f,0.0f);
break;
case KX_ACT_CONSTRAINT_FHPY:
normal[0] = -rotation[0][1];
normal[1] = -rotation[1][1];
normal[2] = -rotation[2][1];
direction = MT_Vector3(0.0f,1.0f,0.0f);
break;
case KX_ACT_CONSTRAINT_FHPZ:
normal[0] = -rotation[0][2];
normal[1] = -rotation[1][2];
normal[2] = -rotation[2][2];
direction = MT_Vector3(0.0f,0.0f,1.0f);
break;
case KX_ACT_CONSTRAINT_FHNX:
normal[0] = rotation[0][0];
normal[1] = rotation[1][0];
normal[2] = rotation[2][0];
direction = MT_Vector3(-1.0f,0.0f,0.0f);
break;
case KX_ACT_CONSTRAINT_FHNY:
normal[0] = rotation[0][1];
normal[1] = rotation[1][1];
normal[2] = rotation[2][1];
direction = MT_Vector3(0.0f,-1.0f,0.0f);
break;
case KX_ACT_CONSTRAINT_FHNZ:
normal[0] = rotation[0][2];
normal[1] = rotation[1][2];
normal[2] = rotation[2][2];
direction = MT_Vector3(0.0f,0.0f,-1.0f);
break;
}
normal.normalize();
{
PHY_IPhysicsEnvironment* pe = KX_GetActiveScene()->GetPhysicsEnvironment();
PHY_IPhysicsController *spc = obj->GetPhysicsController();
if (!pe) {
std::cout << "WARNING: Constraint actuator " << GetName() << ": There is no physics environment!" << std::endl;
goto CHECK_TIME;
}
if (!spc || !spc->IsDynamic()) {
// the object is not dynamic, it won't support setting speed
goto CHECK_TIME;
}
m_hitObject = NULL;
// distance of Fh area is stored in m_minimum
MT_Point3 topoint = position + (m_minimumBound+spc->GetRadius()) * direction;
KX_RayCast::Callback<KX_ConstraintActuator, void> callback(this, spc);
result = KX_RayCast::RayTest(pe, position, topoint, callback);
// we expect a hit object
if (!m_hitObject)
result = false;
if (result)
{
MT_Vector3 newnormal = callback.m_hitNormal;
// compute new position & orientation
MT_Scalar distance = (callback.m_hitPoint-position).length()-spc->GetRadius();
// estimate the velocity of the hit point
MT_Point3 relativeHitPoint;
relativeHitPoint = (callback.m_hitPoint-m_hitObject->NodeGetWorldPosition());
MT_Vector3 velocityHitPoint = m_hitObject->GetVelocity(relativeHitPoint);
MT_Vector3 relativeVelocity = spc->GetLinearVelocity() - velocityHitPoint;
MT_Scalar relativeVelocityRay = direction.dot(relativeVelocity);
MT_Scalar springExtent = 1.0f - distance/m_minimumBound;
// Fh force is stored in m_maximum
MT_Scalar springForce = springExtent * m_maximumBound;
// damping is stored in m_refDirection [0] = damping, [1] = rot damping
MT_Scalar springDamp = relativeVelocityRay * m_refDirVector[0];
MT_Vector3 newVelocity = spc->GetLinearVelocity()-(springForce+springDamp)*direction;
if (m_option & KX_ACT_CONSTRAINT_NORMAL)
{
newVelocity+=(springForce+springDamp)*(newnormal-newnormal.dot(direction)*direction);
}
spc->SetLinearVelocity(newVelocity, false);
if (m_option & KX_ACT_CONSTRAINT_DOROTFH)
{
MT_Vector3 angSpring = (normal.cross(newnormal))*m_maximumBound;
MT_Vector3 angVelocity = spc->GetAngularVelocity();
// remove component that is parallel to normal
angVelocity -= angVelocity.dot(newnormal)*newnormal;
MT_Vector3 angDamp = angVelocity * ((m_refDirVector[1]>MT_EPSILON)?m_refDirVector[1]:m_refDirVector[0]);
spc->SetAngularVelocity(spc->GetAngularVelocity()+(angSpring-angDamp), false);
}
} else if (m_option & KX_ACT_CONSTRAINT_PERMANENT) {
// no contact but still keep running
result = true;
}
// don't set the position with this constraint
goto CHECK_TIME;
}
break;
case KX_ACT_CONSTRAINT_LOCX:
case KX_ACT_CONSTRAINT_LOCY:
case KX_ACT_CONSTRAINT_LOCZ:
newposition = position = obj->GetSGNode()->GetLocalPosition();
switch (m_locrot) {
case KX_ACT_CONSTRAINT_LOCX:
Clamp(newposition[0], m_minimumBound, m_maximumBound);
break;
case KX_ACT_CONSTRAINT_LOCY:
Clamp(newposition[1], m_minimumBound, m_maximumBound);
break;
case KX_ACT_CONSTRAINT_LOCZ:
Clamp(newposition[2], m_minimumBound, m_maximumBound);
break;
}
result = true;
if (m_posDampTime) {
newposition = filter*position + (1.0f-filter)*newposition;
}
obj->NodeSetLocalPosition(newposition);
goto CHECK_TIME;
}
if (result) {
// set the new position but take into account parent if any
obj->NodeSetWorldPosition(newposition);
}
CHECK_TIME:
if (result && m_activeTime > 0 ) {
if (++m_currentTime >= m_activeTime)
result = false;
}
}
if (!result) {
m_currentTime = 0;
}
return result;
} /* end of KX_ConstraintActuator::Update(double curtime,double deltatime) */
void LComponent::llookAndFeelChanged() {
if (child)
callback("lookAndFeelChanged");
}