// ----------------------------------------------------------------------------- // Called when the mouse pointer is moved within the control // ----------------------------------------------------------------------------- void SCallTip::onMouseMove(wxMouseEvent& e) { if (rect_btn_down_.Contains(e.GetPosition())) { if (btn_mouse_over_ != 1) { btn_mouse_over_ = 1; updateBuffer(); Refresh(); Update(); } } else if (rect_btn_up_.Contains(e.GetPosition())) { if (btn_mouse_over_ != 2) { btn_mouse_over_ = 2; updateBuffer(); Refresh(); Update(); } } else if (btn_mouse_over_ != 0) { btn_mouse_over_ = 0; updateBuffer(); Refresh(); Update(); } }
StreamedSound::StreamedSound(AudioStream* stream, ALuint source) :Sound(source),mStream(stream),mDone(false) { alGenBuffers(2, mBuffers); if(updateBuffer(mBuffers[0])) alSourceQueueBuffers(mSource, 1, &mBuffers[0]); if(updateBuffer(mBuffers[1])) alSourceQueueBuffers(mSource, 1, &mBuffers[1]); }
void receiverMain() { int i; char offset; char status; //doCycle(); //doOscillate(); nrf_init(); delay(); nrf_rxmode(); delay(); Delay10KTCYx(100); offset = 0; STATUS_LED = 0; while(1) { //STATUS_LED = nrf_receive(&rx_buf); updateBuffer(); updateLEDs(); } }
void LLAudioChannel::setSource(LLAudioSource *sourcep) { //llinfos << this << ": setSource(" << sourcep << ")" << llendl; if (!sourcep) { // Clearing the source for this channel, don't need to do anything. LL_DEBUGS("AudioEngine") << "Clearing source for channel" << llendl; cleanup(); return; } if (sourcep == mCurrentSourcep) { // Don't reallocate the channel, this will make FMOD goofy. LL_DEBUGS("AudioEngine") << "Calling setSource with same source!" << llendl; } cleanup(); mCurrentSourcep = sourcep; mCurrentSourcep->setChannel(this); updateBuffer(); update3DPosition(); }
void DrawableManager::draw() { m_fbo.bind(); m_fbo.draw({GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3}); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); for (const auto & drawablePair : m_drawables) { const auto & drawType = drawablePair.second; if (drawType.objects.size() == 0 || !drawType.visible) { continue; } if (drawType.dynamic) { updateBuffer(drawablePair.first); } const auto renderType = drawType.objects[0].lock()->renderType; m_renderTypes[renderType].preCall(m_renderTypes[renderType].prog, drawType, m_cam); m_renderTypes[renderType].drawCall(static_cast<GLsizei>(drawType.objects.size())); } m_fbo.unbind(); #ifdef LEGACY_MODE m_fbo.bind(GL_READ_FRAMEBUFFER); glDrawBuffer(GL_BACK); #endif m_fbo.blitAttachment(GL_COLOR_ATTACHMENT3, {0, 0, m_screenSize.x, m_screenSize.y}); #ifdef LEGACY_MODE m_fbo.unbind(); #endif }
lmBool lm::GfxBuffer::init(const lmU8* _buffer, lmU32 _size, GfxBufferType _type, GfxBufferUsage _usage) { m_type = _type; m_usage = _usage; m_size = _size; m_buffer = new lmU8[m_size]; sg_buffer_desc bufferDesc = { 0 }; bufferDesc.type = (sg_buffer_type)_type; bufferDesc.usage = (sg_usage)_usage; if (m_usage == Immutable) { bufferDesc.content = _buffer; bufferDesc.size = _size; m_handle = sg_make_buffer(&bufferDesc); updateBuffer(_buffer, _size); } else { bufferDesc.content = nullptr; bufferDesc.size = _size; m_handle = sg_make_buffer(&bufferDesc); update(_buffer, _size); } return true; }
Texture::Texture(std::vector<GLfloat> c) { _uvCoords = c; updateBuffer(); _tex = 0; }
void LLAudioChannel::setSource(LLAudioSource *sourcep) { //LL_INFOS() << this << ": setSource(" << sourcep << ")" << LL_ENDL; if (!sourcep) { // Clearing the source for this channel, don't need to do anything. //LL_INFOS() << "Clearing source for channel" << LL_ENDL; cleanup(); mCurrentSourcep = NULL; mWaiting = false; } else { LL_DEBUGS("AudioEngine") << "( id: " << sourcep->getID() << ")" << LL_ENDL; if (sourcep == mCurrentSourcep) { // Don't reallocate the channel, this will make FMOD goofy. //LL_INFOS() << "Calling setSource with same source!" << LL_ENDL; } mCurrentSourcep = sourcep; updateBuffer(); update3DPosition(); } }
// Draw all the sprites in this buff void ParticleBuff::renderAll() { // ready the very buffer buildVerts(); // Draw the parts glBindTexture( GL_TEXTURE_2D, m_texId ); glBindBuffer(GL_ARRAY_BUFFER, this->vbo() ); updateBuffer(); glEnableClientState( GL_VERTEX_ARRAY ); glVertexPointer( 2, GL_FLOAT, sizeof(PartiVert), 0 ); glEnableClientState( GL_TEXTURE_COORD_ARRAY ); glTexCoordPointer( 2, GL_FLOAT, sizeof(PartiVert), (void*)(2*sizeof(GLfloat)) ); glEnableClientState( GL_COLOR_ARRAY ); glColorPointer( 4, GL_FLOAT, sizeof(PartiVert), (void*)(4*sizeof(GLfloat)) ); glDrawArrays( GL_TRIANGLES, 0, this->size() ); glDisableClientState( GL_TEXTURE_COORD_ARRAY ); glDisableClientState( GL_COLOR_ARRAY ); glDisableClientState( GL_VERTEX_ARRAY ); }
void pumpRx(COM_Port_t port) { if (checkValidPort(port) == false) { return; } // UART if ( (port == COM_USART0) || (port == COM_USART1) || (port == COM_USART2) ) { uint8_t *buf; UARTDRV_Count_t xferred, remaining; INT_Disable(); UARTDRV_GetReceiveStatus(comhandle[port]->uarthandle, &buf, &xferred, &remaining); updateBuffer(comhandle[port]->rxQueue, xferred, comhandle[port]->rxsize); INT_Enable(); } #ifdef COM_VCP_ENABLE if (port == COM_VCP) { //VCP functionality (VUART) on EFRs do not yet support Rx. return; //x uint8_t rxbyte; //x uint16_t xferred; //x BSP_vcpRead( &rxbyte, 1, 1, &xferred, false ); //x if (xferred>0) //x { //x INT_Disable(); //x FIFO_ENQUEUE(comhandle[port]->rxQueue, rxbyte, comhandle[port]->rxsize); //x INT_Enable(); //x } } #endif }
void veSphereRenderer::render(veNode *node, veRenderableObject *renderableObj, veCamera *camera, unsigned int contextID) { updateBuffer(contextID); veRenderCommand rc; rc.mask = node->getMask(); rc.worldMatrix = new veMat4Ptr(node->getNodeToWorldMatrix()); //rc.attachedNode = node; rc.camera = camera; rc.sceneManager = camera->getSceneManager(); rc.depthInCamera = (camera->viewMatrix() * rc.worldMatrix->value())[2][3]; rc.renderer = this; rc.contextID = contextID; auto material = renderableObj->getMaterial(); for (unsigned int i = 0; i < material->activeTechnique()->getPassNum(); ++i) { auto pass = material->activeTechnique()->getPass(i); if (camera->getMask() & pass->drawMask()) { bool isTransparent = pass->blendFunc() != veBlendFunc::DISABLE ? true : false; rc.pass = pass; pass->visit(rc); if (isTransparent) camera->getRenderQueue()->pushCommand(i, veRenderQueue::RENDER_QUEUE_TRANSPARENT, rc); else camera->getRenderQueue()->pushCommand(i, veRenderQueue::RENDER_QUEUE_ENTITY, rc); } } }
void FileProcessor::getline(int ln) { if (!(fmode == r || fmode == rw)) { return; } updateBuffer(); int i = 0; int ctr = 0; int lineCnt = 1; for (int j = 0; j < length; j++) { if (buffer[j] == '\n') { lineCnt++; } } if (ln > lineCnt) { ln = lineCnt-1; } for (i = 0; i < length; i++) { if (buffer[i] == '\n') { ctr++; if (ctr == ln-1) { break; } } } i++; while (buffer[i] != '\n') { printf("%c", buffer[i]); i++; } }
void LLAudioChannel::setSource(LLAudioSource *sourcep) { //llinfos << this << ": setSource(" << sourcep << ")" << llendl; if (!sourcep) { // Clearing the source for this channel, don't need to do anything. //llinfos << "Clearing source for channel" << llendl; cleanup(); mCurrentSourcep = NULL; mWaiting = false; return; } if (sourcep == mCurrentSourcep) { // Don't reallocate the channel, this will make FMOD goofy. //llinfos << "Calling setSource with same source!" << llendl; } mCurrentSourcep = sourcep; updateBuffer(); update3DPosition(); }
void reGroup::updateShader( reShader* shader ) { if (bufferChanged) { updateBuffer(); } vertexBuffer->bindPointers(shader); }
InteractivePointCloud::InteractivePointCloud(PointBufferPtr buffer) { m_boundingBox = new BoundingBox<Vertex<float> >( Vertex<float>(-8, -8, -8), Vertex<float>(8, 8, 8) ); updateBuffer(buffer); }
/** * Read a value from the sensor, map it over the expected range, average it with the N previous readings and return the average. */ unsigned short BuddleiaSensor::read() { // The raw sensor reading is mapped from the actual range to the expected range. unsigned short reading = expand(analogRead(_pin)); // Average the last N sensor readings to create a smoother effect. updateBuffer(reading); return bufferAverage(); }
Texture::Texture(GLfloat *c, unsigned int n) { for(unsigned int i = 0; i < n; ++i) { _uvCoords.push_back(c[i]); } updateBuffer(); _tex = 0; }
//TODO: Make this work... void Delay::getOutput(double *signal, int length) { input->getOutput(signal, length); updateBuffer(signal, length); for (int i = 0; i < length; i++) { for (int r = 1; r < repetitions; r++) { double delay_contribution = repetition_volumes[r] * buffer[i + r*delay_time]; signal[i] += delay_contribution; } } }
Arrow* Arrow::init() { auto device = ShaderDevise::device(); _start = D3DXVECTOR3(0, 2, 0); _end = D3DXVECTOR3( 0, -2, 0); if(vbuf == NULL) device->CreateVertexBuffer(sizeof(CUSTOMVERTEX)*4, D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX, D3DPOOL_MANAGED, &vbuf, NULL); updateBuffer(); return this; }
cl::Buffer Skeleton::getTransformBuffer(cl::CommandQueue _queue) const { if (!bufferUpdated) { updateBuffer(_queue); bufferUpdated = true; } return transformBuffer; }
void NBodyWindow::display() { updateBuffer(); glClearColor( 0.0f, 0.0f, 0.0f, 0.0f ); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); drawBuffer(); glutSwapBuffers(); glutPostRedisplay(); }
lmBool lm::GfxBuffer::update(const lmU8* _buffer, lmU32 _size) { if (m_buffer != nullptr && _size <= m_size) { updateBuffer(_buffer, _size); sg_update_buffer(m_handle, (const void*)m_buffer, (lm32)_size); return true; } return false; }
void LLAudioChannel::setSource(LLAudioSource *sourcep) { llassert_always(sourcep); llassert_always(!mCurrentSourcep); mCurrentSourcep = sourcep; mCurrentSourcep->setChannel(this); updateBuffer(); update3DPosition(); }
void SysTick_Handler(void){ gpioTogglePin(GPIOD,12); sendBuffer(); count += dir; uint32_t i = 0; for (i = 0; i < numLEDs; i ++){ leds[i] = hsvtorgb((2 * i + offset + count)%255,255,25); // leds[i] = hsvtorgb((offset + count)%255,255,25); } updateBuffer(); }
void TreeLand::renderAll() { //glBindTexture( GL_TEXTURE_2D, m_texId ); //glEnable( GL_TEXTURE ); //glBindTexture( GL_TEXTURE_2D, texId ); glBindBuffer(GL_ARRAY_BUFFER, this->vbo() ); updateBuffer(); //glEnableClientState( GL_VERTEX_ARRAY ); //glVertexPointer( 2, GL_FLOAT, sizeof(TreeVert), 0 ); //glEnableClientState( GL_TEXTURE_COORD_ARRAY ); //glTexCoordPointer( 2, GL_FLOAT, sizeof(TreeVert), (void*)(2*sizeof(GLfloat)) ); //glEnableClientState( GL_COLOR_ARRAY ); //glColorPointer( 4, GL_FLOAT, sizeof(TilemapVert), (void*)(4*sizeof(GLfloat)) ); glEnableVertexAttribArray( Attrib_POSITION ); glVertexAttribPointer( Attrib_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(TreeVert), 0 ); glEnableVertexAttribArray( Attrib_TEXCOORD ); glVertexAttribPointer( Attrib_TEXCOORD, 2, GL_FLOAT, GL_FALSE, sizeof(TreeVert), (void*)(3*sizeof(GLfloat)) ); glDrawArrays( GL_TRIANGLES, 0, this->size() ); glDisableVertexAttribArray( Attrib_POSITION ); //glDisableVertexAttribArray( Attrib_NORMAL ); glDisableVertexAttribArray( Attrib_TEXCOORD ); glActiveTexture( GL_TEXTURE1 ); glEnable( GL_TEXTURE_2D ); glActiveTexture( GL_TEXTURE0 ); glEnable( GL_TEXTURE_2D ); //glDisableClientState( GL_TEXTURE_COORD_ARRAY ); //glDisableClientState( GL_COLOR_ARRAY ); //glDisableClientState( GL_VERTEX_ARRAY ); }
/* * checks if the mode contains w, if not, nothing happens * writes current time and a specified val to file * updates the buffer */ void FileProcessor::write(double val) { if (!(fmode == w || fmode == rw)) { return; } time_t rawtime; struct tm * timeinfo; time ( &rawtime ); timeinfo = localtime ( &rawtime ); char output[100]; char* curtime = asctime (timeinfo); curtime[24] = '\0'; snprintf(output, 100, "%s: %f\n", curtime, val); fprintf(file, output); updateBuffer(); }
void DataThread::run() { while (!threadShouldExit()) { if (!updateBuffer()) { const MessageManagerLock mmLock(Thread::getCurrentThread()); std::cout << "Aquisition error...stopping thread." << std::endl; signalThreadShouldExit(); std::cout << "Notifying source node to stop acqusition." << std::endl; sn->acquisitionStopped(); } } }
void MusicPlayer::createWidgets() { playButton = new QToolButton(this); playButton->setEnabled(false); playButton->setToolTip(tr("Play")); playButton->setIcon(style()->standardIcon(QStyle::SP_MediaPlay)); connect(playButton, SIGNAL(clicked()), this, SLOT(togglePlayback())); connect(playButton, SIGNAL(clicked()), this->parent(), SLOT(updateBuffer())); /* QAbstractButton *openButton = new QToolButton(this); openButton->setText(tr("...")); openButton->setToolTip(tr("Open a file...")); openButton->setFixedSize(playButton->sizeHint()); connect(openButton, SIGNAL(clicked()), this, SLOT(openFile())); */ volumeButton = new VolumeButton(this); volumeButton->setToolTip(tr("Adjust volume")); volumeButton->setVolume(mediaPlayer.volume()); connect(volumeButton, SIGNAL(volumeChanged(int)), &mediaPlayer, SLOT(setVolume(int))); positionSlider = new QSlider(Qt::Horizontal, this); positionSlider->setEnabled(false); positionSlider->setToolTip(tr("Seek")); connect(positionSlider, SIGNAL(valueChanged(int)), this, SLOT(setPosition(int))); infoLabel = new QLabel(this); positionLabel = new QLabel(tr("00:00"), this); positionLabel->setMinimumWidth(positionLabel->sizeHint().width()); QBoxLayout *controlLayout = new QHBoxLayout; controlLayout->setMargin(0); //controlLayout->addWidget(openButton); controlLayout->addWidget(playButton); controlLayout->addWidget(positionSlider); controlLayout->addWidget(positionLabel); controlLayout->addWidget(volumeButton); QBoxLayout *mainLayout = new QVBoxLayout(this); mainLayout->addWidget(infoLabel); mainLayout->addLayout(controlLayout); }
void StreamedSound::update() { // once it's all been streamed, it's just a matter of waiting for the // buffers to be finished off... if(!mDone) { int processed = 0; alGetSourcei(mSource, AL_BUFFERS_PROCESSED, &processed); // unqueue, stream to and requeue any processed buffers while(processed--) { ALuint buffer; alSourceUnqueueBuffers(mSource, 1, &buffer); if(updateBuffer(buffer)) alSourceQueueBuffers(mSource, 1, &buffer); } } }
bool Particles::update(float dt){ for(auto &it : data){ it.lifetime -= dt; it.position += (it.velocity + wind*it.mass)*dt/1000.f; it.velocity -= it.velocity*drag; it.size += it.mass * dt/2000.f; } /// cleanup u32 last = data.size(); for(u32 i=0; i<last; i++){ if(data[i].lifetime <= 0.f){ data[i].size = 0.f; data[i] = data[--last]; } } data.resize(std::min(last, MAX_PARTICLES)); updateBuffer(); return false; }