RefreshLiveviewEvent::
RefreshLiveviewEvent(double refresh_interval, int min_delay, Visualization &vis)
:vis_(&vis),
refresh_interval_(refresh_interval)
{
#ifdef HAVE_BOOST
boost::xtime_get(&last_refresh_, boost::TIME_UTC);
last_refresh_.sec -= 1;
boost::mutex::scoped_lock lock(*getUpdateMutex());
#endif
min_delay_time_ = min_delay;
// Convert to Nanoseconds as needed by boost::thread:
min_delay_time_ *= 1000000;
// Writes current network state to texture.
write_frame();
// Informs the external window that texture data has changed.
updateTexture(getTexture());
}
void Menu::step(float dt)
{
if(!active) return;
int deltaScroll = 0;
bool update = false;
sf::Vector2f mouse = sf::Vector2f(sf::Mouse::getPosition(Application::getWindow()));
sf::Vector2f relMouse = mouse - spr.getPosition();
sf::Vector2f mouseInView = rndrTxtre.mapPixelToCoords(static_cast<sf::Vector2i>(relMouse));
if(scroll && sf::Mouse::isButtonPressed(sf::Mouse::Left) && contains(scrollBar.getPosition().x,spr.getPosition().y,scrollBar.getSize().x,view.getSize().y,mouse.x,mouse.y))
{
int new_scrolled = (menuList.size()-itemsVisible+1)*relMouse.y/(view.getSize().y);
if(new_scrolled != scrolled)
{
deltaScroll = new_scrolled-scrolled;
update = true;
}
}
if(update) updateTexture(deltaScroll);
}
void Vinyl::setImage () {
quad.clear();
ofDisableArbTex();
quad.getVertices().resize(4);
quad.getTexCoords().resize(4);
quad.setMode(OF_PRIMITIVE_TRIANGLE_FAN);
vinylHeight = (ofGetHeight()-HEADER_HEIGHT-FOOTER_HEIGHT);
s = PIXELS_READING/vinylImage.getHeight();
w = vinylImage.getWidth()*s;
h = vinylImage.getHeight()*s;
vinylImage.resize(w, h);
if(vinylImage.bAllocated()){
updateTexture();
}
}
Card(Value v, Suit s, bool FaceUp) {
faceup = FaceUp;
value = v;
suit = s;
const std::string str(std::string("Cards/")
.append(intStringValues[static_cast<int>(value)])
.append("_of_")
.append(stringSuits[static_cast<int>(suit)])
.append(".png"));
std::cout << str << ", value =" << static_cast<int>(value)<< ", suit = " << static_cast<int>(suit) << std::endl;
if (!face.loadFromFile(str)) { // TODO error
std::cout << "Couldn't load card img" << std::endl;
} else {
updateTexture();
std::cout << "Left: " << sprite.getLocalBounds().left
<< ", width: " << sprite.getLocalBounds().width
<< ", top: " << sprite.getLocalBounds().top
<< ", height: " << sprite.getLocalBounds().height << std::endl;
}
}
/**Allocate resources for the lookup table and the volume on the GPU.
* Prerequisite: SetImage and SetcolorTable has been called.
*
* Call this from inside a PrepareForRendering() methods in vtk.
*/
virtual void allocate()
{
if (mAllocated) // do this only once.
{
return;
}
if (!mTexture)
{
std::cout << "error: bad volume buffer initialization" << std::endl;
return;
}
glActiveTexture(GL_TEXTURE7);
glEnable(GL_TEXTURE_3D);
glGenTextures(1, &textureId);
glDisable(GL_TEXTURE_3D);
updateTexture();
mAllocated = true;
}
void receiver() {
int size;
while ((size = recv(sock, buff, sizeof(buff), MSG_DONTWAIT)) > 0) {
//printf("recved %d\n", size);
if (buff[0] != type) {
synced = 0;
}
type = buff[0];
switch (type) {
case 1: // raw
raw_seq = buff[1] << 8 | buff[2];
raw_line = buff[3];
setLine(raw_line, buff+6, size-6);
if (raw_line == h-1) {
updateTexture();
}
break;
case 2: // cmpr
case 3: // cmpr3
cmpr_seq = buff[1] << 8 | buff[2];
if (cmpr_seq != cmpr_next) {
synced = 0;
printf("packet lost %d -> %d\n", (int)cmpr_next, (int)cmpr_seq);
}
cmpr_next = cmpr_seq+1;
//printf("received compression unit %d\n", cmpr_seq);
if (type == 2)
decompress(buff+3, size-3);
else
decompress3(buff+3, size-3);
break;
default:
break;
}
// XXX do on end of frame
}
}
void MediaPlayerPrivateGStreamerBase::paintToTextureMapper(TextureMapper* textureMapper, const FloatRect& targetRect, const TransformationMatrix& matrix, float opacity)
{
if (!m_player->visible())
return;
if (m_usingFallbackVideoSink) {
if (RefPtr<BitmapTexture> texture = updateTexture(textureMapper))
textureMapper->drawTexture(*texture.get(), targetRect, matrix, opacity);
return;
}
#if USE(GSTREAMER_GL)
if (!GST_IS_SAMPLE(m_sample.get()))
return;
GstCaps* caps = gst_sample_get_caps(m_sample.get());
if (!caps)
return;
GstVideoInfo videoInfo;
gst_video_info_init(&videoInfo);
if (!gst_video_info_from_caps(&videoInfo, caps))
return;
GstBuffer* buffer = gst_sample_get_buffer(m_sample.get());
GstVideoFrame videoFrame;
if (!gst_video_frame_map(&videoFrame, &videoInfo, buffer, static_cast<GstMapFlags>(GST_MAP_READ | GST_MAP_GL)))
return;
unsigned textureID = *reinterpret_cast<unsigned*>(videoFrame.data[0]);
BitmapTexture::Flags flags = BitmapTexture::NoFlag;
if (GST_VIDEO_INFO_HAS_ALPHA(&videoInfo))
flags |= BitmapTexture::SupportsAlpha;
IntSize size = IntSize(GST_VIDEO_INFO_WIDTH(&videoInfo), GST_VIDEO_INFO_HEIGHT(&videoInfo));
TextureMapperGL* textureMapperGL = reinterpret_cast<TextureMapperGL*>(textureMapper);
textureMapperGL->drawTexture(textureID, flags, size, targetRect, matrix, opacity);
gst_video_frame_unmap(&videoFrame);
#endif
}
void Image::updateDrawables()
{
if(m_upd_recreate)
{
destroyDrawables();
createDrawables();
}
if(m_upd_geometry)
{
updateGeometry();
}
if(m_upd_xf)
{
updateTransform();
}
if(m_upd_texture)
{
updateTexture();
}
if(m_upd_tile_ratio)
{
updateTileRatio();
}
if(m_upd_smooth)
{
updateSmooth();
}
if(m_upd_opacity)
{
updateOpacity();
}
m_upd_recreate = false;
m_upd_geometry = false;
m_upd_xf = false;
m_upd_texture = false;
m_upd_tile_ratio = false;
m_upd_smooth = false;
m_upd_opacity = false;
}
void display()
{
HandleOpcode();
if(DrawFlag)
{
// Clear framebuffer
glClear(GL_COLOR_BUFFER_BIT);
#ifdef DRAWWITHTEXTURE
updateTexture();
#else
updateQuads();
#endif
// Swap buffers!
glutSwapBuffers();
// Processed frame
DrawFlag = 0;
}
}
/**
* Function to render and display content.
*/
GLUSboolean update(GLUSfloat time)
{
static GLfloat passedTime = 0.0f;
static GLUSfloat angle = 0.0f;
// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clear.html
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
glUseProgram(g_programBackground.program);
// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
glUniformMatrix4fv(g_modelViewLocationBackground, 1, GL_FALSE, g_modelView);
// ToDo:
glBindVertexArray(g_vaoBackground);
// ToDo:
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
//http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/enable.html
glEnable( GL_CULL_FACE);
// http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml
glDrawElements(GL_TRIANGLES, g_numberIndicesBackground, GL_UNSIGNED_INT, 0);
// Update the texture
updateTexture(passedTime);
// Render the water scene
renderWater(passedTime, angle);
passedTime += time;
angle += 2.0f * PIf / 120.0f * time;
return GLUS_TRUE;
}
//--------------------------------------------------------------------------------
void ofxCvImage::draw( float x, float y, float w, float h ) {
if( bUseTexture ) {
updateTexture();
tex.draw(x,y, w,h);
} else {
#ifdef TARGET_OPENGLES
ofLog(OF_LOG_ERROR, "texture-less drawing not supported in OpenGL ES");
#else
// this is slower than the typical draw method based on textures
// but useful when dealing with threads GL textures often don't work
ofLog(OF_LOG_NOTICE, "in draw, using slow texture-less drawing");
ofLog(OF_LOG_NOTICE, "texture-less drawing - be aware, unlike texture drawing, \
this always draws window aligned, rotation not supported");
if( x == 0) {
x += 0.01;
ofLog(OF_LOG_NOTICE, "BUG: can't draw at x==0 in texture-less mode.");
}
if(bAnchorIsPct){
x -= anchor.x * w;
y -= anchor.y * h;
}else{
x -= anchor.x;
y -= anchor.y;
}
glRasterPos2f( x, y+h );
IplImage* tempImg;
tempImg = cvCreateImage( cvSize((int)w, (int)h), ipldepth, iplchannels );
cvResize( cvImage, tempImg, CV_INTER_NN );
cvFlip( tempImg, tempImg, 0 );
glDrawPixels( tempImg->width, tempImg->height ,
glchannels, gldepth, tempImg->imageData );
cvReleaseImage( &tempImg );
#endif
}
}
//--------------------------------------------------------------------------------
void ofxCvImage::draw( float x, float y, float w, float h ) {
if( bUseTexture ) {
updateTexture();
tex.draw(x,y, w,h);
} else {
#ifdef TARGET_OPENGLES
ofLogError("ofxCvImage") << "draw(): textureless drawing mode not supported in OpenGL ES";
#else
// this is slower than the typical draw method based on textures
// but useful when dealing with threads GL textures often don't work
ofLogNotice("ofxCvImage") << "draw(): using textureless drawing mode";
ofLogNotice("ofxCvImage") << "draw(): drawing is slower, aligned to the window, & does not support rotation";
if( x == 0) {
ofLogNotice("ofxCvImage") << "draw(): x position cannot be 0 in textureless drawing mode, setting to 0.01";
x += 0.01;
}
if(bAnchorIsPct){
x -= anchor.x * w;
y -= anchor.y * h;
}else{
x -= anchor.x;
y -= anchor.y;
}
glRasterPos2f( x, y+h );
IplImage* tempImg;
tempImg = cvCreateImage( cvSize((int)w, (int)h), ipldepth, iplchannels );
cvResize( cvImage, tempImg, CV_INTER_NN );
cvFlip( tempImg, tempImg, 0 );
glDrawPixels( tempImg->width, tempImg->height ,
glchannels, gldepth, tempImg->imageData );
cvReleaseImage( &tempImg );
#endif
}
}
void FluidDrawerBase::drawColor(float x, float y, float renderWidth, float renderHeight, bool withAlpha) {
if(enabled == false) return;
if(useAdditiveBlending) {
glBlendFunc(GL_ONE, GL_ONE);
glEnable(GL_BLEND);
} else {
glDisable(GL_BLEND);
}
int fw = _fluidSolver->getWidth();
int fh = _fluidSolver->getHeight();
ofVec2f vel;
ofColor color;
int index = 0;
for(int j=1; j < fh-1; j++) {
for(int i=1; i < fw-1; i++) {
_fluidSolver->getInfoAtCell(i, j, &vel, &color);
int r = (unsigned char)min(color.r * 255 * brightness, 255.0f);
int g = (unsigned char)min(color.g * 255 * brightness, 255.0f);
int b = (unsigned char)min(color.b * 255 * brightness, 255.0f);
if(doInvert) {
r = 255 - r;
g = 255 - g;
b = 255 - b;
}
_pixels[index++] = r;
_pixels[index++] = g;
_pixels[index++] = b;
if(_alphaEnabled) _pixels[index++] = withAlpha ? max(b, max(r, g)) : 255;
}
}
updateTexture();
drawTexture(x, y, renderWidth, renderHeight);
}
void reposition(const QRect& frameGeometry, QSize& fullSize)
{
QRect nodeRect = FrameSvgHelpers::sectionRect(m_border, frameGeometry, fullSize);
//ensure we're not passing a weird rectangle to updateTexturedRectGeometry
if(!nodeRect.isValid() || nodeRect.isEmpty())
nodeRect = QRect();
//the position of the relevant texture within this texture ID.
//for atlas' this will only be a small part of the texture
QRectF textureRect;
if (m_fitMode == Tile) {
textureRect = QRectF(0,0,1,1); //we can never be in an atlas for tiled images.
//if tiling horizontally
if (m_border == FrameSvg::TopBorder || m_border == FrameSvg::BottomBorder || m_border == FrameSvg::NoBorder) {
textureRect.setWidth(nodeRect.width() / m_elementNativeSize.width());
}
//if tiling vertically
if (m_border == FrameSvg::LeftBorder || m_border == FrameSvg::RightBorder || m_border == FrameSvg::NoBorder) {
textureRect.setHeight(nodeRect.height() / m_elementNativeSize.height());
}
} else if (m_fitMode == Stretch) {
QString prefix = m_frameSvg->frameSvg()->actualPrefix();
QString elementId = prefix + FrameSvgHelpers::borderToElementId(m_border);
//re-render the SVG at new size
updateTexture(nodeRect.size(), elementId);
textureRect = texture()->normalizedTextureSubRect();
} else if (texture()) { // for fast stretch.
textureRect = texture()->normalizedTextureSubRect();
}
QSGGeometry::updateTexturedRectGeometry(geometry(), nodeRect, textureRect);
markDirty(QSGNode::DirtyGeometry);
}
// ----------------------------------------------------------------------
void RefreshLiveviewEvent::timeout(shawn::EventScheduler &es,
shawn::EventScheduler::EventHandle eh, double t,
shawn::EventScheduler::EventTagHandle &)
throw()
{
#ifdef HAVE_BOOST
// Compute timestamp of next refresh.
last_refresh_.nsec += min_delay_time_;
// Sleeps until next refresh (if needed, maybe already reached).
boost::thread::sleep(last_refresh_);
// Start refresh and mark current time as time of last refresh.
boost::xtime_get(&last_refresh_, boost::TIME_UTC);
// Lock the texture update mutex!
boost::mutex::scoped_lock lock(*getUpdateMutex());
#endif
// Writes current network state to texture.
write_frame();
// Informs the external window that texture data has changed.
updateTexture(getTexture());
// Re-schedules the event for next execution.
es.move_event(eh, t + refresh_interval_);
}
//--------------------------------------------------------------
void DrawerBase::drawColor(float x, float y, float renderWidth, float renderHeight, bool withAlpha) const {
if(enabled == false) return;
ofPushStyle();
if(useAdditiveBlending) ofEnableBlendMode(OF_BLENDMODE_ADD);
else ofDisableAlphaBlending();
int fw = _fluidSolver->getWidth();
int fh = _fluidSolver->getHeight();
Vec2f vel;
Color color;
int index = 0;
for(int j=1; j < fh-1; j++) {
for(int i=1; i < fw-1; i++) {
_fluidSolver->getInfoAtCell(i, j, &vel, &color);
int r = (unsigned char)min(color.r * 255 * brightness, 255.0f);
int g = (unsigned char)min(color.g * 255 * brightness, 255.0f);
int b = (unsigned char)min(color.b * 255 * brightness, 255.0f);
if(doInvert) {
r = 255 - r;
g = 255 - g;
b = 255 - b;
}
_pixels[index++] = r;
_pixels[index++] = g;
_pixels[index++] = b;
if(_alphaEnabled) _pixels[index++] = withAlpha ? max(b, max(r, g)) : 255;
}
}
updateTexture();
drawTexture(x, y, renderWidth, renderHeight);
ofPopStyle();
}
void ColourPanel::updateFromColour(const MyGUI::Colour& _colour)
{
mCurrentColour = _colour;
if (!mAlphaSupport)
mCurrentColour.alpha = 1;
std::vector<float> vec;
vec.push_back(mCurrentColour.red);
vec.push_back(mCurrentColour.green);
vec.push_back(mCurrentColour.blue);
std::sort(vec.begin(), vec.end());
MyGUI::IntPoint point((int)((1 - vec[0] / vec[2]) * mColourRect->getWidth()), (int)((1 - vec[2]) * mColourRect->getHeight()));
mImageColourPicker->setPosition(point.left - (mImageColourPicker->getWidth() / 2), point.top - (mImageColourPicker->getHeight() / 2));
int iMax = (mCurrentColour.red == vec[2]) ? 0 : (mCurrentColour.green == vec[2]) ? 1 : 2;
int iMin = (mCurrentColour.red == vec[0]) ? 0 : (mCurrentColour.green == vec[0]) ? 1 : 2;
int iAvg = 3 - iMax - iMin;
if (iMin == iMax) // if gray colour - set base red
{
iMax = 0;
iMin = 1;
iAvg = 2;
byIndex(mBaseColour, iMin) = 0.;
byIndex(mBaseColour, iAvg) = 0.;
byIndex(mBaseColour, iMax) = 1.;
}
else
{
byIndex(mBaseColour, iMin) = 0.;
byIndex(mBaseColour, iAvg) = (vec[1] - vec[0]) / (vec[2] - vec[0]);
byIndex(mBaseColour, iMax) = 1.;
}
int i;
for (i = 0; i < 6; ++i)
{
if ((fabs(byIndex(mColourRange[i], iMin) - byIndex(mBaseColour, iMin)) < 0.001) &&
(fabs(byIndex(mColourRange[i], iMax) - byIndex(mBaseColour, iMax)) < 0.001) &&
(fabs(byIndex(mColourRange[i+1], iMin) - byIndex(mBaseColour, iMin)) < 0.001) &&
(fabs(byIndex(mColourRange[i+1], iMax) - byIndex(mBaseColour, iMax)) < 0.001))
break;
}
float sector_size = (float)mScrollRange->getScrollRange() / 6.0f;
size_t current = i;
float offset = byIndex(mBaseColour, iAvg);
if (byIndex(mColourRange[i+1], iAvg) < byIndex(mColourRange[i], iAvg)) offset = 1 - byIndex(mBaseColour, iAvg);
size_t pos = size_t((current + offset) * sector_size);
mScrollRange->setScrollPosition(pos);
// бонус для обрезки цвета под шкалу
mBaseColour.red = mColourRange[i].red + offset * (mColourRange[i+1].red - mColourRange[i].red);
mBaseColour.green = mColourRange[i].green + offset * (mColourRange[i+1].green - mColourRange[i].green);
mBaseColour.blue = mColourRange[i].blue + offset * (mColourRange[i+1].blue - mColourRange[i].blue);
updateTexture(mBaseColour);
mAlphaSlider->setScrollPosition((size_t)((double)(mAlphaSlider->getScrollRange() - 1) * (double)mCurrentColour.alpha));
mColourView->setColour(mCurrentColour);
mColourView->setAlpha(mCurrentColour.alpha);
mAlphaSliderBack->setColour(mCurrentColour);
eventPreviewColour(mCurrentColour);
}
void setFaceUp(bool faceUp) {
faceup = faceUp;
updateTexture();
}
void Flip() {
faceup = !faceup;
updateTexture();
}
void StateTextureControl::updateSkinProperties()
{
updateTexture();
updateCoord();
}
//----------------------------------------------------------
ofTexture& ofFbo::getTexture(int attachmentPoint) {
updateTexture(attachmentPoint);
return textures[attachmentPoint];
}
tgt::Texture* TransFunc::getTexture() {
if (textureInvalid_)
updateTexture();
return tex_;
}
void Menu::passEvent(const sf::Event &event)
{
if(!active) return;
bool update = false;
int deltaScroll = 0;
if(event.type == sf::Event::KeyPressed)
{
switch(event.key.code)
{
case sf::Keyboard::Up:
if(--marker < 0)
{
marker = menuList.size()-1;
deltaScroll = menuList.size()-itemsVisible;
}
else if(marker < scrolled)
deltaScroll = -1;
update = true;
break;
case sf::Keyboard::Down:
if(size_t(++marker) > menuList.size()-1)
{
deltaScroll = -menuList.size()+itemsVisible;
marker = 0;
}
else if(marker-scrolled+1>itemsVisible)
deltaScroll = 1;
update = true;
break;
case sf::Keyboard::Return:
clicked = marker;
break;
default:
break;
}
}
else if(event.type == sf::Event::MouseMoved)
{
sf::Vector2f mouse(event.mouseMove.x,event.mouseMove.y);
sf::Vector2f mouseInView = rndrTxtre.mapPixelToCoords(sf::Vector2i(mouse) - sf::Vector2i(spr.getPosition()));
if(spr.getGlobalBounds().contains(mouse) && mouseInView.y/(linePadding+characterSize) != marker && mouseInView.y/(linePadding+characterSize)-scrolled <= menuList.size())
{
marker = mouseInView.y/(linePadding+characterSize);
update = true;
}
}
else if(event.type == sf::Event::MouseButtonPressed)
{
sf::Vector2f mouse(event.mouseButton.x,event.mouseButton.y);
sf::Vector2f mouseInView = rndrTxtre.mapPixelToCoords(sf::Vector2i(mouse) - sf::Vector2i(spr.getPosition()));
if(spr.getGlobalBounds().contains(mouse) && mouseInView.y/(linePadding+characterSize) != marker && mouseInView.y/(linePadding+characterSize)-scrolled <= menuList.size())
{
clicked = marker = mouseInView.y/(linePadding+characterSize);
update = true;
}
}
else if(event.type == sf::Event::MouseWheelMoved)
{
if(-event.mouseWheel.delta+scrolled+itemsVisible <= int(menuList.size()) && -event.mouseWheel.delta+scrolled >= 0)
{
sf::Vector2f mouse(event.mouseWheel.x,event.mouseWheel.y);
if(spr.getGlobalBounds().contains(mouse))
{
deltaScroll = -event.mouseWheel.delta;
update = true;
mouse.y += deltaScroll*(linePadding+characterSize);//adjust for the new scroll
mouse -= spr.getPosition();
mouse = rndrTxtre.mapPixelToCoords(static_cast<sf::Vector2i>(mouse));
if(mouse.y/(linePadding+characterSize) != marker/* && mouse.y/(linePadding+characterSize)-scrolled <= itemsVisible*/)
marker = mouse.y/(linePadding+characterSize);
}
}
}
if(update) updateTexture(deltaScroll);
}
// Updates the rendered scene
void GLDvrWidget::updateContent() {
if(mp_volume) {
updateTexture(); // Update the texture buffer
updateGL(); // Update the display (cautomatically call paintGL())
}
}
int Tile::increaseValue() noexcept
{
m_Value *= 2;
updateTexture();
return m_Value;
}
GLubyte* TransFunc::getPixelData() {
if (textureInvalid_)
updateTexture();
tgtAssert(tex_, "No texture");
return tex_->getPixelData();
}
MatWindow::MatWindow(QWidget *parent)
: QWidget(parent)
{
setWindowTitle(tr("View/Change Material"));
setWindowFlags(Qt::Dialog);
setMinimumSize(QSize(400, 500));
setMaximumSize(QSize(400, 500));
treeMat = new QTreeWidget(this);
treeMat->setHeaderLabels(QStringList("Sub Entities"));
treeMat->setMinimumSize(150, 150);
connect(treeMat, SIGNAL(itemClicked(QTreeWidgetItem*, int)), this, SLOT(processMat(QTreeWidgetItem*)));
textureLbl = new QLabel("Texture Preview");
textureLbl->setPixmap(tr("settings.png"));
textureLbl->setMinimumSize(150, 150);
matText = new QTextEdit;
matText->setMinimumSize(300, 200);
connect(matText, SIGNAL(textChanged()), this, SLOT(updateTexture()));
//Textures
viewTexture = new QGroupBox(tr("View Texture"));
treeTextureLayout = new QHBoxLayout;
treeTextureLayout->addWidget(treeMat);
treeTextureLayout->addWidget(textureLbl);
viewTexture->setLayout(treeTextureLayout);
//////////
//Material
viewMat = new QGroupBox(tr("View Material"));
matLayout = new QVBoxLayout;
matLayout->addWidget(matText);
viewMat->setLayout(matLayout);
////////////
//Btn
groupBtn = new QGroupBox;
groupBtn->setFlat(true);
okBtn = new QPushButton(tr("&Ok"));
okBtn->setMaximumSize(QSize(75, 25));
connect(okBtn, SIGNAL(clicked()), this, SLOT(saveMat()));
cancelBtn = new QPushButton(tr("&Cancel"));
cancelBtn->setMaximumSize(QSize(75, 25));
connect(cancelBtn, SIGNAL(clicked()), this, SLOT(close()));
btnLayout = new QGridLayout;
btnLayout->addWidget(okBtn, 0, 1);
btnLayout->addWidget(cancelBtn, 0, 2);
btnLayout->setAlignment(okBtn, Qt::AlignRight & Qt::AlignBottom);
btnLayout->setAlignment(cancelBtn, Qt::AlignRight & Qt::AlignBottom);
groupBtn->setLayout(btnLayout);
///////////
gridLayout = new QVBoxLayout;
gridLayout->addWidget(viewTexture);
gridLayout->addWidget(viewMat);
gridLayout->addWidget(groupBtn);
setLayout(gridLayout);
scriptPath += QDir::currentPath()+"/media/materials/scripts/";
texturePath += QDir::currentPath()+"/media/materials/textures/";
posMat = -1;
nextMat = -1;
strAllMat = "";
}
//--------------------------------------------------------------
void ofxThreadedVideo::update(){
if(lock()){
// check if we're loading a video
if(loadVideoID != VIDEO_NONE){
videos[loadVideoID].update();
float w = videos[loadVideoID].getWidth();
float h = videos[loadVideoID].getHeight();
// allocate a texture if the one we have is a different size
if(bUseTexture && (textures[loadVideoID].getWidth() != w || textures[loadVideoID].getHeight() != h)){
ofLogVerbose() << "Allocating texture" << loadVideoID << w << h;
textures[loadVideoID].allocate(w, h, ofGetGLTypeFromPixelFormat(internalPixelFormat));
}
// check for a new frame before loading video
if(bFrameNew[loadVideoID]){
// switch the current movie ID to the one we just loaded
int lastVideoID = currentVideoID;
currentVideoID = loadVideoID;
loadVideoID = VIDEO_NONE;
// close the last movie - we do this here because
// ofQuicktimeVideo chokes if you try to close in a thread
if(lastVideoID != VIDEO_NONE){
ofLogVerbose() << "Closing last video" << lastVideoID;
paths[lastVideoID] = names[lastVideoID] = "";
videos[lastVideoID].stop();
// reset properties to defaults
newPosition[lastVideoID] = -1.0f;
newFrame[lastVideoID] = -1;
newSpeed[lastVideoID] = 1.0f;
newLoopType[lastVideoID] = -1;
frame[lastVideoID] = 0;
bFrameNew[lastVideoID] = false;
bPaused[lastVideoID] = false;
volume[lastVideoID] = 255;
}
// send event notification
ofxThreadedVideoEvent videoEvent = ofxThreadedVideoEvent(paths[currentVideoID], VIDEO_EVENT_LOAD_OK, this);
ofNotifyEvent(threadedVideoEvent, videoEvent, this);
}
}
// check for a new frame for current video
updateTexture(currentVideoID);
// if there's a movie in the queue
if(pathsToLoad.size() > 0 && loadPath == "" && loadVideoID == VIDEO_NONE){
// ...let's start trying to load it!
loadPath = pathsToLoad.front();
pathsToLoad.pop();
};
// calculate frameRate -> taken from ofAppRunner
prevMillis = ofGetElapsedTimeMillis();
timeNow = ofGetElapsedTimef();
double diff = timeNow-timeThen;
if( diff > 0.00001 ){
fps = 1.0 / diff;
frameRate *= 0.9f;
frameRate += 0.1f*fps;
}
lastFrameTime = diff;
timeThen = timeNow;
unlock();
}
}
void Canvas::textureInvalidate(ITexture* _texture)
{
updateTexture();
}
void iil4mitkImage::drawTextures (iil4mitkWidget* widget)
{
const unsigned int s = _size; // size of the tiles
unsigned int n, m; // number of the tiles
n = (unsigned int) ceilf ((float) _rw / (float) (s - 2));
m = (unsigned int) ceilf ((float) _rh / (float) (s - 2));
/* Allocate memory for the textures */
Textures* textures;
{
iil4mitkWidget* w;
unsigned int available, total;
//w = (widget->IsSharing () ? widget->SharedWidget () : widget);
w = (false ? NULL : widget);
std::map<void*,Textures*>::iterator tex_it = _textures.find (w);
if(tex_it!=_textures.end())
textures = tex_it->second;
else
textures = NULL;
if (!textures) {
textures = new Textures ();
typedef std::pair <void*, std::vector<_iil4mitkTexture*>* > TexturePair;
_textures.insert (TexturePair(w, textures));
}
available = textures->size ();
total = n * m;
//textures->resize (total);
int iii;
for (unsigned int i = available; i < total; i++)
{
textures->push_back(new _iil4mitkTexture (w));
iii=textures->size ();
}
widget->MakeCurrent ();
}
/* Render the textures */
glScalef ((float) (s-2), (float) (s-2), 1.0);
for (unsigned int i = 0; i < n; i++)
{
unsigned int pos [2]; // left-top corner of the region
unsigned int len [2]; // extent of the region
unsigned int tex [2]; // size of the texture
float res [2]; // resolution of the texture
pos [0] = _rx+i*(s-2);
len [0] = (pos[0]+(s-2)>_rw ? _rw-pos[0] : s-2);
tex [0] = power2(s);
res [0] = 1.0f/tex[0];
for (unsigned int j = 0; j < m; j++)
{
_iil4mitkTexture* texture;
texture = (*textures)[i*m+j];
pos [1] = _ry+j*(s-2);
len [1] = (pos[1]+(s-2)>_rh ? _rh-pos[1] : s-2);
tex [1] = power2(s);
res [1] = 1.0f/tex[1];
//if (widget->isVisible (pos [0], pos [1], len [0], len [1])) {
if (true) {
// widget->makeCurrent ();
texture->bind ();
// widget->makeCurrent ();
texture->setSize (tex[0], tex[1]);
texture->setModel (_model);
texture->setInterpolation (_interpolation);
if (!texture->isValid ())
{
updateTexture (texture, pos[0], pos[1], len[0], len[1]);
}
glBegin (GL_QUADS);
glTexCoord2f (res[0], res[1]); glVertex3f (0.0, 0.0, 0.0);
glTexCoord2f (1.0-res[0], res[1]); glVertex3f (1.0, 0.0, 0.0);
glTexCoord2f (1.0-res[0], 1.0-res[1]); glVertex3f (1.0, 1.0, 0.0);
glTexCoord2f (res[0], 1.0-res[1]); glVertex3f (0.0, 1.0, 0.0);
glEnd ();
}
glTranslatef (0.0, 1.0, 0.0);
}
glTranslatef (1.0, -((float) m), 0.0);
}
}
