int prLID_GetAbsInfo(VMGlobals *g, int numArgsPushed) { PyrSlot* args = g->sp - 2; int evtCode; int err; PyrObject* obj = SC_LID::getObject(args+0); if (!obj) return errWrongType; err = slotIntVal(args+1, &evtCode); if (err) return err; if (!isKindOfSlot(args+2, s_absInfoClass->u.classobj)) return errWrongType; PyrObject* infoObj = slotRawObject(&args[2]); SC_LID* dev = SC_LID::getDevice(obj); if (!dev) return errFailed; struct input_absinfo info; err = dev->getAbsInfo(evtCode, &info); if (err) return err; SetInt(infoObj->slots+0, info.value); SetInt(infoObj->slots+1, info.minimum); SetInt(infoObj->slots+2, info.maximum); SetInt(infoObj->slots+3, info.fuzz); SetInt(infoObj->slots+4, info.flat); slotCopy(&args[0], &args[2]); return errNone; }
bool OnInitDialog() { SetInt(IDC_EDIT1,p.x); SetInt(IDC_EDIT2,p.y); return true; }
void Shader::UpdateUniforms(RenderingEngine& _renderingEngine) { for (unsigned int i = 0; i < shaderData->uniformNames.size(); i++) { string uniformName = shaderData->uniformNames[i]; string uniformType = shaderData->uniformTypes[i]; if (uniformName.substr(0, 2) == "R_") { string unprefixedName = uniformName.substr(2, uniformName.length()); if (unprefixedName == "lightMatrix") { SetMatrix4(uniformName, 1, _renderingEngine.GetLightMatrix()); } else if (uniformType == "sampler2D") { int samplerSlot = _renderingEngine.GetSamplerSlot(unprefixedName); _renderingEngine.GetTexture(unprefixedName)->Bind(samplerSlot); SetInt(uniformName, samplerSlot); } else if (uniformType == "vec3") { SetVector3(uniformName, *_renderingEngine.GetVector3(unprefixedName)); } else if (uniformType == "float") { SetFloat(uniformName, *_renderingEngine.GetFloat(unprefixedName)); } else if (uniformType == "int") { if (uniformName == "R_DIR_LIGHT_COUNT") { SetInt(uniformName, _renderingEngine.GetActiveDirLights().size()); } if (uniformName == "R_POINT_LIGHT_COUNT") { SetInt(uniformName, _renderingEngine.GetActivePointLights().size()); } } else if (uniformType == "DirLight") { SetDirectionalLights(uniformName, _renderingEngine.GetActiveDirLights()); } else if (uniformType == "PointLight") { SetPointLights(uniformName, _renderingEngine.GetActivePointLights()); } else { throw "Invalid R_ Uniform:" + uniformName; } } } }
void PushQueueEvents_CalibratedValue (){ IOHIDEventStruct event; pRecDevice pCurrentHIDDevice = HIDGetFirstDevice (); int numdevs = gNumberOfHIDDevices; unsigned char result; for(int i=0; i< numdevs; i++){ result = HIDGetEvent(pCurrentHIDDevice, (void*) &event); if(result && compiledOK) { SInt32 value = event.value; int vendorID = pCurrentHIDDevice->vendorID; int productID = pCurrentHIDDevice->productID; int locID = pCurrentHIDDevice->locID; IOHIDElementCookie cookie = (IOHIDElementCookie) event.elementCookie; pRecElement pCurrentHIDElement = HIDGetFirstDeviceElement (pCurrentHIDDevice, kHIDElementTypeAll); // use gElementCookie to find current element while (pCurrentHIDElement && ( (pCurrentHIDElement->cookie) != cookie)) pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeAll); if (pCurrentHIDElement) { value = HIDCalibrateValue(value, pCurrentHIDElement); //find element to calibrate VMGlobals *g = gMainVMGlobals; pthread_mutex_lock (&gLangMutex); g->canCallOS = false; // cannot call the OS ++g->sp; SetObject(g->sp, s_hid->u.classobj); // Set the class HIDService //set arguments: ++g->sp;SetInt(g->sp, vendorID); ++g->sp;SetInt(g->sp, productID); ++g->sp;SetInt(g->sp, locID); ++g->sp;SetInt(g->sp, (int) cookie); ++g->sp;SetInt(g->sp, value); runInterpreter(g, s_hidAction, 6); g->canCallOS = false; // cannot call the OS pthread_mutex_unlock (&gLangMutex); } } /* FIXME: this does not seem to be working! if ( !HIDIsValidDevice(pCurrentHIDDevice) ) { // readError post("HID: read Error\n"); int locID = pCurrentHIDDevice->locID; VMGlobals *g = gMainVMGlobals; pthread_mutex_lock (&gLangMutex); g->canCallOS = false; // cannot call the OS ++g->sp; SetObject(g->sp, s_hid->u.classobj); // Set the class HIDService ++g->sp;SetInt(g->sp, locID); runInterpreter(g, s_readError, 2); g->canCallOS = false; // cannot call the OS pthread_mutex_unlock (&gLangMutex); }*/ pCurrentHIDDevice = HIDGetNextDevice(pCurrentHIDDevice); } }
KeyValues::KeyValues(const char *setName, const char *firstKey, int firstValue, const char *secondKey, int secondValue) { TRACK_KV_ADD(this, setName); Init(); SetName(setName); SetInt(firstKey, firstValue); SetInt(secondKey, secondValue); }
PyrObject* ConvertReplyAddress(ReplyAddress *inReply) { VMGlobals *g = gMainVMGlobals; PyrObject *obj = instantiateObject(g->gc, s_netaddr->u.classobj, 2, true, false); PyrSlot *slots = obj->slots; SetInt(slots+0, ntohl(inReply->mSockAddr.sin_addr.s_addr)); SetInt(slots+1, ntohs(inReply->mSockAddr.sin_port)); return obj; }
void inv_hack_on() { cInv = TRUE; ZeroMemory(pak, 20); SetShort(0, 0); SetShort(0, 2); SetShort(0xAD9, 4); SetShort(GetClientID(), 6); SetInt(0, 8); SetInt(2, 12); SetInt(1, 16); SendPacket(pak, 20); }
///////////////////////////////////////////////////////// // Resets a value with a string, preserving current type void VariableData::ResetWith(wxString value) { switch (type) { case VARDATA_INT: { long temp = 0; value.ToLong(&temp); SetInt(temp); break; } case VARDATA_FLOAT: { double temp = 0; value.ToDouble(&temp); SetFloat(temp); break; } case VARDATA_BOOL: if (value == _T("1")) SetBool(true); else SetBool(false); break; case VARDATA_COLOUR: { long r=0,g=0,b=0; value.Mid(1,2).ToLong(&r,16); value.Mid(3,2).ToLong(&g,16); value.Mid(5,2).ToLong(&b,16); SetColour(wxColour(r,g,b)); break; } default: SetText(value); break; } }
int prGetLangPort(VMGlobals *g, int numArgsPushed) { PyrSlot *a = g->sp; if (!gUDPport) return errFailed; SetInt(a, gUDPport->RealPortNum()); return errNone; }
void flext_base::cb_int(flext_hdr *c,long v) { t_atom atom; SetInt(atom,v); Locker lock(c); int const ci = proxy_getinlet((t_object *)&c->obj); thisObject(c)->CbMethodHandler(ci,sym_int,1,&atom); }
TBValue::TBValue(TYPE type) : m_packed_init(0) { switch (type) { case TYPE_NULL: SetNull(); break; case TYPE_STRING: SetString("", SET_AS_STATIC); break; case TYPE_FLOAT: SetFloat(0); break; case TYPE_INT: SetInt(0); break; case TYPE_OBJECT: SetObject(nullptr); break; case TYPE_ARRAY: if (TBValueArray *arr = new TBValueArray()) SetArray(arr, SET_TAKE_OWNERSHIP); break; default: assert(!"Not implemented!"); }; }
int prPipeOpen(struct VMGlobals *g, int numArgsPushed) { PyrSlot *a, *b, *c; char mode[12]; PyrFile *pfile; FILE *file; a = g->sp - 2; b = g->sp - 1; c = g->sp; if (NotObj(c) || !isKindOf(slotRawObject(c), class_string) || NotObj(b) || !isKindOf(slotRawObject(b), class_string)) return errWrongType; if (slotRawObject(c)->size > 11) return errFailed; pfile = (PyrFile*)slotRawObject(a); char *commandLine = (char*)malloc(slotRawObject(b)->size + 1); memcpy(commandLine, slotRawString(b)->s, slotRawObject(b)->size); commandLine[slotRawString(b)->size] = 0; memcpy(mode, slotRawString(c)->s, slotRawObject(c)->size); mode[slotRawString(c)->size] = 0; pid_t pid; file = sc_popen(commandLine, &pid, mode); free(commandLine); if (file) { SetPtr(&pfile->fileptr, file); SetInt(a, pid); } else { SetNil(a); } return errNone; }
void PerformOSCBundle(int inSize, char* inData, PyrObject *replyObj, int inPortNum) { // convert all data to arrays int64 oscTime = OSCtime(inData + 8); double seconds = OSCToElapsedTime(oscTime); VMGlobals *g = gMainVMGlobals; char *data = inData + 16; char* dataEnd = inData + inSize; while (data < dataEnd) { int32 msgSize = OSCint(data); data += sizeof(int32); if (IsBundle(data)) { PerformOSCBundle(msgSize, data, replyObj, inPortNum); } else // is a message { ++g->sp; SetObject(g->sp, g->process); ++g->sp; SetFloat(g->sp, seconds); ++g->sp; SetObject(g->sp, replyObj); ++g->sp; SetInt(g->sp, inPortNum); PyrObject *arrayObj = ConvertOSCMessage(msgSize, data); ++g->sp; SetObject(g->sp, arrayObj); runInterpreter(g, s_recvoscmsg, 5); } data += msgSize; } }
void PriorityQueueAdd(struct VMGlobals *g, PyrObject* queueobj, PyrSlot* item, double time) { PyrObject *schedq, *newschedq; int size, maxsize; PyrSlot *schedqSlot = queueobj->slots; if (!IsObj(schedqSlot)) { size = 32; schedq = newPyrArray(g->gc, size, 0, true); schedq->size = 1; SetInt(schedq->slots + 0, 0); // stability count SetObject(schedqSlot, schedq); g->gc->GCWriteNew(queueobj, schedq); // we know schedq is white so we can use GCWriteNew } else { schedq = slotRawObject(schedqSlot); maxsize = ARRAYMAXINDEXSIZE(schedq); size = schedq->size; if (size+3 > maxsize) { newschedq = newPyrArray(g->gc, maxsize*2, 0, true); newschedq->size = size; slotCopy(newschedq->slots, schedq->slots, size); assert(IsInt(newschedq->slots)); SetObject(schedqSlot, newschedq); g->gc->GCWriteNew(queueobj, newschedq); // we know newschedq is white so we can use GCWriteNew schedq = newschedq; } } addheap(g, schedq, time, item); }
/************************************* * operator = *************************************/ SHVDataVariant& SHVDataVariantImpl::operator=(const SHVDataVariant& val) { switch (val.GetDataType()) { case SHVDataVariant::TypeInt: SetInt(val.AsInt()); break; case SHVDataVariant::TypeInt64: SetInt64(val.AsInt64()); break; case SHVDataVariant::TypeBool: SetBool(val.AsBool()); break; case SHVDataVariant::TypeDouble: SetDouble(val.AsDouble()); break; case SHVDataVariant::TypeString: SetString(val.AsString()); break; case SHVDataVariant::TypeTime: SetTime(val.AsTime()); break; } return *this; }
void PkyProperty::SetInt( const char* pszSect, const char* pszKey, int val ) { auto const strSect= StringConvert::toWstring( pszSect ); auto const strKey = StringConvert::toWstring( pszKey ); return SetInt(strSect.c_str(), strKey.c_str(), val ); }
int prHIDGetValue(VMGlobals *g, int numArgsPushed) { PyrSlot *a = g->sp - 2; //class PyrSlot *b = g->sp - 1; //locID device PyrSlot *c = g->sp; //element cookie int locID, cookieNum; int err = slotIntVal(b, &locID); if (err) return err; err = slotIntVal(c, &cookieNum); if (err) return err; IOHIDElementCookie cookie = (IOHIDElementCookie) cookieNum; //look for the right device: pRecDevice pCurrentHIDDevice = HIDGetFirstDevice (); while (pCurrentHIDDevice && (pCurrentHIDDevice->locID !=locID)) pCurrentHIDDevice = HIDGetNextDevice (pCurrentHIDDevice); if(!pCurrentHIDDevice) return errFailed; //look for the right element: pRecElement pCurrentHIDElement = HIDGetFirstDeviceElement (pCurrentHIDDevice, kHIDElementTypeAll); // use gElementCookie to find current element while (pCurrentHIDElement && (pCurrentHIDElement->cookie != cookie)) pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeAll); if (pCurrentHIDElement) { SInt32 value = HIDGetElementValue (pCurrentHIDDevice, pCurrentHIDElement); // if it's not a button and it's not a hatswitch then calibrate if(( pCurrentHIDElement->type != kIOHIDElementTypeInput_Button ) && ( pCurrentHIDElement->usagePage == 0x01 && pCurrentHIDElement->usage != kHIDUsage_GD_Hatswitch)) value = HIDCalibrateValue ( value, pCurrentHIDElement ); SetInt(a, value); } else SetNil(a); return errNone; }
void MyTweener::AddInt(int* var, int startvalue, int endvalue, double tweentime, MyTweenType tweentype, double delay, bool updatewhiledelayed, unsigned int id) { TweenInt* pVar = MyNew TweenInt; m_ListOfVars.Add( (TweenVar*)pVar ); SetInt( m_ListOfVars.Count()-1, var, startvalue, endvalue, tweentime, tweentype, delay, updatewhiledelayed, id ); }
PListValue& PListValue::operator =(const PListValue& rhs) { switch (rhs.type_) { case PLVT_NONE: Reset(); break; case PLVT_INT: SetInt(rhs.int_); break; case PLVT_BOOL: SetBool(rhs.bool_); break; case PLVT_FLOAT: SetFloat(rhs.float_); break; case PLVT_STRING: SetString(*rhs.string_); break; case PLVT_VALUEMAP: SetValueMap(*rhs.valueMap_); break; case PLVT_VALUEVECTOR: SetValueVector(*rhs.valueVector_); break; } return *this; }
void SC_LID::handleEvent(struct input_event& evt) { if (evt.type != EV_SYN) { pthread_mutex_lock(&gLangMutex); if (compiledOK) { VMGlobals* g = gMainVMGlobals; g->canCallOS = false; ++g->sp; SetObject(g->sp, m_obj); ++g->sp; SetInt(g->sp, evt.type); ++g->sp; SetInt(g->sp, evt.code); ++g->sp; SetInt(g->sp, evt.value); runInterpreter(g, s_handleEvent, 4); g->canCallOS = false; } pthread_mutex_unlock(&gLangMutex); } }
int prSymbol_SpecialIndex(struct VMGlobals *g, int numArgsPushed) { PyrSlot *a = g->sp; SetInt(a, slotRawSymbol(a)->specialIndex); return errNone; }
void g2Spinner::IncrementDown() { // Decrease and bounds check float & int respectively if(Type == g2SpinnerType_Float) SetFloat(fmax(fmin(GetFloat() - FloatInc, FloatMax), FloatMin)); else if(Type == g2SpinnerType_Int) SetInt((int)fmax(fmin(GetInt() - IntInc, IntMax), IntMin)); }
int prUnix_Errno(struct VMGlobals *g, int numArgsPushed) { PyrSlot *a = g->sp; SetInt(a, errno); return errNone; }
int prSFOpenRead(struct VMGlobals *g, int numArgsPushed) { PyrSlot *a, *b; char filename[PATH_MAX]; SNDFILE *file; SF_INFO info; const char *headerstr; const char *sampleformatstr; a = g->sp - 1; b = g->sp; PyrObject *obj1 = slotRawObject(a); if (!isKindOfSlot(b, class_string)) return errWrongType; if (slotRawObject(b)->size > PATH_MAX - 1) return errFailed; memcpy(filename, slotRawString(b)->s, slotRawObject(b)->size); filename[slotRawString(b)->size] = 0; info.format = 0; file = sf_open(filename, SFM_READ, &info); if (file) { SetPtr(obj1->slots + 0, file); sndfileFormatInfoToStrings(&info, &headerstr, &sampleformatstr); //headerFormatToString(&info, &headerstr); PyrString *hpstr = newPyrString(g->gc, headerstr, 0, true); SetObject(obj1->slots+1, hpstr); g->gc->GCWriteNew(obj1, (PyrObjectHdr*)hpstr); // we know hpstr is white so we can use GCWriteNew PyrString *smpstr = newPyrString(g->gc, sampleformatstr, 0, true); SetObject(obj1->slots+2, smpstr); g->gc->GCWriteNew(obj1, (PyrObjectHdr*)smpstr); // we know smpstr is white so we can use GCWriteNew SetInt(obj1->slots + 3, info.frames); SetInt(obj1->slots + 4, info.channels); SetInt(obj1->slots + 5, info.samplerate); SetTrue(a); } else { SetNil(a); SetFalse(a); } return errNone; }
int prAs32Bits(VMGlobals *g, int numArgsPushed) { PyrSlot *a = g->sp; // return an integer that is a bit pattern for the 32 bit float representation union { float f; int32 i; } u; u.f = slotRawFloat(a); SetInt(a, u.i); return errNone; }
void Color::SetFloats(float r, float g, float b, float a) { int R = static_cast<int>(r * 255.0f); int G = static_cast<int>(g * 255.0f); int B = static_cast<int>(b * 255.0f); int A = static_cast<int>(a * 255.0f); SetInt(R, G, B, A); }
int prSymbol_AsInteger(struct VMGlobals *g, int numArgsPushed) { PyrSlot *a = g->sp; char *str = slotRawSymbol(a)->name; SetInt(a, atoi(str)); return errNone; }
//------------------------------------------------------------------------------------------------------------------------------------------------------ int Settings::GetInt(char *name) { int retValue = mapIntChild[IntKey(name)]; if(!GetIntFromChild(name, &retValue)) { SetInt(name, retValue); } return retValue; }
PyrObject* ConvertOSCMessage(int inSize, char *inData) { char *cmdName = inData; int cmdNameLen = OSCstrlen(cmdName); sc_msg_iter msg(inSize - cmdNameLen, inData + cmdNameLen); int numElems; if (inSize == cmdNameLen) { numElems = 0; } else { if (!msg.tags) { numElems = 0; error("OSC messages must have type tags. %s\n", cmdName); } else { numElems = strlen(msg.tags); } } //post("tags %s %d\n", msg.tags, numElems); VMGlobals *g = gMainVMGlobals; PyrObject *obj = newPyrArray(g->gc, numElems + 1, 0, false); PyrSlot *slots = obj->slots; SetSymbol(slots+0, getsym(cmdName)); for (int i=0; i<numElems; ++i) { char tag = msg.nextTag(); //post("%d %c\n", i, tag); switch (tag) { case 'i' : SetInt(slots+i+1, msg.geti()); break; case 'f' : SetFloat(slots+i+1, msg.getf()); break; case 'd' : SetFloat(slots+i+1, msg.getd()); break; case 's' : SetSymbol(slots+i+1, getsym(msg.gets())); //post("sym '%s'\n", slots[i+1].us->name); break; case 'b' : SetObject(slots+i+1, (PyrObject*)MsgToInt8Array(msg)); break; case 'c': SetChar(slots+i+1, (char)msg.geti()); break; // else add the type tag as a char (jrhb 2009) default: SetChar(slots+i+1, tag); msg.gets(); } } obj->size = numElems + 1; return obj; }
static int prSerialPort_RXErrors(struct VMGlobals *g, int numArgsPushed) { PyrSlot* self = g->sp; SerialPort* port = (SerialPort*)getSerialPort(self); if (port == 0) return errFailed; SetInt(self, port->rxErrors()); return errNone; }