OpenSceneGraph Forum Forum Index OpenSceneGraph Forum
Official forum which mirrors the existent OSG mailing lists. Messages posted here are forwarded to the mailing list and vice versa.
 
   FAQFAQ    SearchSearch    MemberlistMemberlist    RulesRules    UsergroupsUsergroups    RegisterRegister 
 Mail2Forum SettingsMail2Forum Settings  ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 
   AlbumAlbum  OpenSceneGraph IRC ChatOpenSceneGraph IRC Chat   SmartFeedSmartFeed 

Float Texture = unable to register image object (cudaGraphicsGLRegisterImage()).


 
Post new topic   Reply to topic    OpenSceneGraph Forum Forum Index -> osgCompute [osgCompute]
View previous topic :: View next topic  
Author Message
sholmes
User


Joined: 05 Sep 2011
Posts: 62

PostPosted: Thu May 01, 2014 9:15 pm    Post subject:
Float Texture = unable to register image object (cudaGraphicsGLRegisterImage()).
Reply with quote

Hi,

I have modified one of the osgCompute examples to try to learn a bit about osgCompute/CUDA... I am trying to take 3 float textures, and use a CUDA kernel to create a 4 texture which is a combination of the the 3 input textures. This works if I create 3 GL_RGBA/GL_UNSIGNED_BYTE textures, btu when I try to use float textures, using GL_RGBA32F_ARB/GL_FLOAT, I get the following errors:


alloc srcTexture0:unable to register image object (cudaGraphicsGLRegisterImage()). Not all GL formats are supported.invalid argument.
unmap srcTexture0: error during device memory synchronization (map()).
alloc srcTexture1:unable to register image object (cudaGraphicsGLRegisterImage()). Not all GL formats are supported.invalid argument.
unmap srcTexture1: error during device memory synchronization (map()).
alloc srcTexture2:unable to register image object (cudaGraphicsGLRegisterImage()). Not all GL formats are supported.invalid argument.
unmap srcTexture2: error during device memory synchronization (map()).
alloc trgBuffer:unable to register image object (cudaGraphicsGLRegisterImage()). Not all GL formats are supported.invalid argument.
unmap trgBuffer: error during device memory synchronization (map()).


Can someone help me out and tell me what i am doing wrong here?

This is my code:

/* osgCompute - Copyright (C) 2008-2009 SVT Group
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 3 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesse General Public License for more details.
*
* The full license is in LICENSE file included with this distribution.
*/

#include <iostream>
#include <sstream>
#include <osg/ArgumentParser>
#include <osg/Texture2D>
#include <osg/Vec4ub>
#include <osg/BlendFunc>
#include <osg/Geometry>
#include <osg/ShapeDrawable>
#include <osg/MatrixTransform>
#include <osgDB/ReadFile>
#include <osgDB/WriteFile>
#include <osgDB/FileUtils>
#include <osgDB/Registry>
#include <osgViewer/CompositeViewer>
#include <osgGA/TrackballManipulator>
#include <osgViewer/ViewerEventHandlers>
#include <osgCompute/Computation>
#include <osgCompute/Callback>
#include <osgCuda/Buffer>
#include <osgCuda/Texture>
#include <osgCuda/Computation>
#include <osgCudaStats/Stats>
#include <osgCudaInit/Init>

extern "C" void mix( unsigned int numPixelsX,
unsigned int numPixelsY,
void* trgBuffer,
void* srcBuffer0,
float srcBuffer0Fract,
void* srcBuffer1,
float srcBuffer1Fract,
void* srcBuffer2,
float srcBuffer2Fract,
unsigned int srcBufferSize );

///////////////////////////////////////////////////////////////////////////////////////////
//
//
//
///////////////////////////////////////////////////////////////////////////////////////////
class TexFilter : public osgCompute::Program
{
public:
//------------------------------------------------------------------------------
virtual void launch()
{
if( !_trgBuffer.valid() || !_srcBuffer0.valid() || !_srcBuffer1.valid() || !_srcBuffer2.valid())
return;

if( !_timer.valid() )
{
_timer = new osgCuda::Timer;
_timer->setName( "TexFilter");
}

_timer->start();

mix( _trgBuffer->getDimension(0),
_trgBuffer->getDimension(1),
_trgBuffer->map( osgCompute::MAP_DEVICE_TARGET ),
_srcBuffer0->map( osgCompute::MAP_DEVICE_SOURCE ),
_srcBuffer0Fract,
_srcBuffer1->map( osgCompute::MAP_DEVICE_SOURCE ),
_srcBuffer1Fract,
_srcBuffer2->map( osgCompute::MAP_DEVICE_SOURCE ),
_srcBuffer2Fract,
_srcBuffer0->getByteSize( osgCompute::MAP_DEVICE ) );


_timer->stop();
}

//------------------------------------------------------------------------------
virtual void acceptResource( osgCompute::Resource& resource )
{
if( resource.isIdentifiedBy("TRG_BUFFER") )
_trgBuffer = dynamic_cast<osgCompute::Memory*>( &resource );
if( resource.isIdentifiedBy("SRC_BUFFER0") )
_srcBuffer0 = dynamic_cast<osgCompute::Memory*>( &resource );
if( resource.isIdentifiedBy("SRC_BUFFER1") )
_srcBuffer1 = dynamic_cast<osgCompute::Memory*>( &resource );
if( resource.isIdentifiedBy("SRC_BUFFER2") )
_srcBuffer2 = dynamic_cast<osgCompute::Memory*>( &resource );
}

public:
void setSrcBufferFractions(float srcBuffer0Fract, float srcBuffer1Fract, float srcBuffer2Fract)
{
_srcBuffer0Fract = srcBuffer0Fract;
_srcBuffer1Fract = srcBuffer1Fract;
_srcBuffer2Fract = srcBuffer2Fract;
}

private:
osg::ref_ptr<osgCompute::Memory> _srcBuffer0;
osg::ref_ptr<osgCompute::Memory> _srcBuffer1;
osg::ref_ptr<osgCompute::Memory> _srcBuffer2;
osg::ref_ptr<osgCompute::Memory> _trgBuffer;
osg::ref_ptr<osgCuda::Timer> _timer;

float _srcBuffer0Fract;
float _srcBuffer1Fract;
float _srcBuffer2Fract;
};


///////////////////////////////////////////////////////////////////////////////////////////
//
//
//
///////////////////////////////////////////////////////////////////////////////////////////
osg::ref_ptr<osg::Node> setupScene()
{
// CREATE TEXTURE RESOURCES //
int textureWidth = 512;
int textureHeight = 512;
int size = textureWidth * textureHeight * 4;

///////////////////////////////////////////////////////////////////////////////////////////
// create RED Texture and display quad
///////////////////////////////////////////////////////////////////////////////////////////
osg::ref_ptr< osgCuda::Texture2D > srcTexture0 = new osgCuda::Texture2D;
{
srcTexture0->setTextureSize(512, 512);
srcTexture0->setInternalFormat(GL_RGBA32F_ARB);
srcTexture0->setSourceType( GL_FLOAT );
srcTexture0->setName( "srcTexture0" );
srcTexture0->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
srcTexture0->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);
srcTexture0->addIdentifier("SRC_BUFFER0");

osg::Image* sourceImage = new osg::Image;
if(sourceImage)
{
sourceImage->allocateImage(textureWidth, textureHeight, 1, GL_RGBA32F_ARB, GL_FLOAT);
GLfloat* dataPtr = (GLfloat*)sourceImage->data();
if(dataPtr)
{
for(int row = 0; row < textureHeight; row++)
{
float value = 0;
for(int col = 0; col < textureHeight; col++)
{
int idx = row * textureWidth + col;
int i = 4 * idx;
dataPtr[i + 0] = 1.0f;
dataPtr[i + 1] = 0.0f;
dataPtr[i + 2] = 0.0f;
dataPtr[i + 3] = 1.0f;
}
}
srcTexture0->setImage(sourceImage);
}
}
}
osg::ref_ptr<osg::Geode> sourceQuad0 = new osg::Geode;
{
sourceQuad0->setDataVariance( osg::Object::DYNAMIC );
sourceQuad0->addDrawable( osg::createTexturedQuadGeometry( osg::Vec3(-1.1, 0, 0.1), osg::Vec3(1,0,0), osg::Vec3(0,0,1) ) );
sourceQuad0->getOrCreateStateSet()->setTextureAttributeAndModes( 0, srcTexture0.get(), osg::StateAttribute:ShockedN );
}

///////////////////////////////////////////////////////////////////////////////////////////
// create GREEN Texture and display quad
///////////////////////////////////////////////////////////////////////////////////////////
osg::ref_ptr< osgCuda::Texture2D > srcTexture1 = new osgCuda::Texture2D;
{
srcTexture1->setTextureSize(512, 512);
srcTexture1->setInternalFormat(GL_RGBA32F_ARB);
srcTexture1->setSourceType( GL_FLOAT );
srcTexture1->setName( "srcTexture1" );
srcTexture1->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
srcTexture1->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);
srcTexture1->addIdentifier("SRC_BUFFER1");

osg::Image* sourceImage = new osg::Image;
if(sourceImage)
{
sourceImage->allocateImage(textureWidth, textureHeight, 1, GL_RGBA32F_ARB, GL_FLOAT);
GLfloat* dataPtr = (GLfloat*)sourceImage->data();
if(dataPtr)
{
for(int row = 0; row < textureHeight; row++)
{
float value = 0;
for(int col = 0; col < textureHeight; col++)
{
int idx = row * textureWidth + col;
int i = 4 * idx;
dataPtr[i + 0] = 0.0f;
dataPtr[i + 1] = 1.0f;
dataPtr[i + 2] = 0.0f;
dataPtr[i + 3] = 1.0f;
}
}
srcTexture1->setImage(sourceImage);
}
}
}
osg::ref_ptr<osg::Geode> sourceQuad1 = new osg::Geode;
{
sourceQuad1->setDataVariance( osg::Object::DYNAMIC );
sourceQuad1->addDrawable( osg::createTexturedQuadGeometry( osg::Vec3(0.1, 0, 0.1), osg::Vec3(1,0,0), osg::Vec3(0,0,1) ) );
sourceQuad1->getOrCreateStateSet()->setTextureAttributeAndModes( 0, srcTexture1.get(), osg::StateAttribute:ShockedN );
}

///////////////////////////////////////////////////////////////////////////////////////////
// create BLUE Texture and display quad
///////////////////////////////////////////////////////////////////////////////////////////
osg::ref_ptr< osgCuda::Texture2D > srcTexture2 = new osgCuda::Texture2D;
{
srcTexture2->setTextureSize(512, 512);
srcTexture2->setInternalFormat(GL_RGBA32F_ARB);
srcTexture2->setSourceType( GL_FLOAT );
srcTexture2->setName( "srcTexture2" );
srcTexture2->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
srcTexture2->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::LINEAR);
srcTexture2->addIdentifier("SRC_BUFFER2");

osg::Image* sourceImage = new osg::Image;
if(sourceImage)
{
sourceImage->allocateImage(textureWidth, textureHeight, 1, GL_RGBA32F_ARB, GL_FLOAT);
GLfloat* dataPtr = (GLfloat*)sourceImage->data();
if(dataPtr)
{
for(int row = 0; row < textureHeight; row++)
{
float value = 0;
for(int col = 0; col < textureHeight; col++)
{
int idx = row * textureWidth + col;
int i = 4 * idx;
dataPtr[i + 0] = 0.0f;
dataPtr[i + 1] = 0.0f;
dataPtr[i + 2] = 1.0f;
dataPtr[i + 3] = 1.0f;
}
}
srcTexture2->setImage(sourceImage);
}
}

}
osg::ref_ptr<osg::Geode> sourceQuad2 = new osg::Geode;
{
sourceQuad2->setDataVariance( osg::Object::DYNAMIC );
sourceQuad2->addDrawable( osg::createTexturedQuadGeometry( osg::Vec3(-1.1, 0, -1.1), osg::Vec3(1,0,0), osg::Vec3(0,0,1) ) );
sourceQuad2->getOrCreateStateSet()->setTextureAttributeAndModes( 0, srcTexture2.get(), osg::StateAttribute:ShockedN );
}

///////////////////////////////////////////////////////////////////////////////////////////
// create TARGET Texture and Quad
///////////////////////////////////////////////////////////////////////////////////////////
osg::ref_ptr< osgCuda::Texture2D > targetTexture = new osgCuda::Texture2D;
{
targetTexture->setTextureSize(512, 512);
targetTexture->setInternalFormat(GL_RGBA32F_ARB);
targetTexture->setSourceType( GL_FLOAT );
targetTexture->setName( "trgBuffer" );
targetTexture->setFilter(osg::Texture2D::MIN_FILTER,osg::Texture2D::LINEAR);
targetTexture->setFilter(osg::Texture2D::MAG_FILTER,osg::Texture2D::NEAREST);
targetTexture->addIdentifier("TRG_BUFFER");
}
osg::ref_ptr<osg::Geode> resultQuad = new osg::Geode;
{
resultQuad->setDataVariance( osg::Object::DYNAMIC );
resultQuad->addDrawable( osg::createTexturedQuadGeometry( osg::Vec3(0.1,0,-1.1), osg::Vec3(1,0,0), osg::Vec3(0,0,1) ) );
resultQuad->getOrCreateStateSet()->setTextureAttributeAndModes( 0, targetTexture.get(), osg::StateAttribute:ShockedN );
}

///////////////////////////////////////////////////////////////////////////////////////////
// Create Computation
///////////////////////////////////////////////////////////////////////////////////////////
osg::ref_ptr<osgCuda::Computation> computation = new osgCuda::Computation;
{
osg::ref_ptr<TexFilter> texFilter = new TexFilter;
texFilter->setSrcBufferFractions(1.0f, 1.0f, 1.0f);

computation->addProgram( *texFilter );

computation->setComputeOrder( osgCompute::Computation::PRE_RENDER );

computation->addResource( *(srcTexture0->getMemory()) );
computation->addResource( *(srcTexture1->getMemory()) );
computation->addResource( *(srcTexture2->getMemory()) );
computation->addResource( *(targetTexture->getMemory()) );
}

osg::ref_ptr<osg::Group> scene = new osg::Group;
{
scene->addChild( sourceQuad0 );
scene->addChild( sourceQuad1 );
scene->addChild( sourceQuad2 );
scene->addChild( resultQuad );
scene->addChild( computation );
}

return scene;
}

//------------------------------------------------------------------------------
int main(int argc, char *argv[])
{
osg::setNotifyLevel( osg::INFO );

////////////////////////////////////////////////////////////////////////////
osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
if (!wsi)
{
osg::notify(osg::NOTICE)<<"Error, no WindowSystemInterface available, cannot create windows."<<std::endl;
return 1;
}

unsigned int windowWidth = 512;
unsigned int windowHeight = 512;

osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
traits->x = 10;
traits->y = 10;
traits->width = windowWidth;
traits->height = windowHeight;
traits->windowDecoration = true;
traits->doubleBuffer = true;
traits->sharedContext = 0;

osg::ref_ptr<osg::GraphicsContext> graphicsContext = osg::GraphicsContext::createGraphicsContext(traits.get());
if (graphicsContext.valid())
{
osg::notify(osg::INFO)<<" GraphicsWindow has been created successfully."<<std::endl;
graphicsContext->setClearColor(osg::Vec4f(0.2f,0.2f,0.6f,1.0f));
graphicsContext->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
else
{
osg::notify(osg::NOTICE)<<" GraphicsWindow has not been created successfully."<<std::endl;
}


osgViewer::CompositeViewer viewer;

viewer.setThreadingModel(osgViewer::CompositeViewer::SingleThreaded);
viewer.setReleaseContextAtEndOfFrameHint(false);

osg::ref_ptr<osgViewer::View> mainView = new osgViewer::View;
mainView->setName("Main View");
mainView->getCamera()->setGraphicsContext(graphicsContext);
mainView->getCamera()->setViewport(0, 0, windowWidth, windowHeight);
mainView->setCameraManipulator(new osgGA::TrackballManipulator);

mainView->addEventHandler(new osgViewer::StatsHandler);
mainView->addEventHandler(new osgCuda::StatsHandler);

viewer.addView(mainView);

///////////////////////
// LINK CUDA AND OSG //
///////////////////////
// setupOsgCudaAndViewer() creates the OpenGL context
// and binds it to the CUDA context of the thread.
osgCuda::setupOsgCudaAndViewer( viewer );


/////////////////
// SETUP SCENE //
/////////////////
mainView->setSceneData( setupScene() );


viewer.realize();

while (!viewer.done())
{
viewer.advance();
viewer.eventTraversal();
viewer.updateTraversal();
viewer.renderingTraversals();
}

}



...


Thank you!

Cheers,
Conan
Code:
Back to top
View user's profile Send private message
Display posts from previous:   
Post new topic   Reply to topic    OpenSceneGraph Forum Forum Index -> osgCompute [osgCompute] All times are GMT
Page 1 of 1

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
You cannot attach files in this forum
You cannot download files in this forum

Similar Topics
Topic Author Forum Replies Posted
No new posts Render to texture with GL3. Raizel General 3 Tue May 23, 2017 10:33 am View latest post
No new posts scene object not receiving/casting sh... Meldryt General 0 Thu May 11, 2017 8:01 am View latest post
No new posts Scale problem while transforming obje... YuraIU02 General 1 Sat Apr 15, 2017 4:26 pm View latest post
No new posts How to get Node object from PositionA... nghien_rbc General 1 Sat Apr 15, 2017 3:05 am View latest post
No new posts How to get the orientation of 3d object? Jiechang Guo General 2 Mon Apr 10, 2017 2:14 pm View latest post


Board Security Anti Bot Question MOD - phpBB MOD against Spam Bots
Powered by phpBB © 2001, 2005 phpBB Group
Protected by Anti-Spam ACP