GLTexture2D* GPUMemMan::Load2DTextureFromFile(const string& strFilename, int iShareGroupID) {
for (SimpleTextureListIter i = m_vpSimpleTextures.begin();
i < m_vpSimpleTextures.end(); ++i) {
if (i->strFilename == strFilename && i->m_iShareGroupID == iShareGroupID) {
MESSAGE("Reusing %s", strFilename.c_str());
i->iAccessCounter++;
return i->pTexture;
}
}
#ifndef TUVOK_NO_QT
QImage image;
if (!image.load(strFilename.c_str())) {
T_ERROR("Unable to load file %s", strFilename.c_str());
return NULL;
}
MESSAGE("Loaded %s, now creating OpenGL resources ..", strFilename.c_str());
QImage glimage = QGLWidget::convertToGLFormat(image);
GLTexture2D* tex = new GLTexture2D(glimage.width(),glimage.height(),
GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE,
glimage.bits());
m_iAllocatedGPUMemory += tex->GetGPUSize();
m_iAllocatedCPUMemory += tex->GetCPUSize();
m_vpSimpleTextures.push_back(SimpleTextureListElem(1,tex,strFilename,iShareGroupID));
return tex;
#else
T_ERROR("No Qt support!");
return NULL;
#endif
}
// static
GLTexture2D* GLTexture2D::createTexture2D( int width, int height,
GLTexture::GLTextureInternalFormat internalFormat )
{
GLTexture2D* pTexture = new GLTexture2D( width, height, internalFormat );
pTexture->setAllWrapModes( GL_CLAMP );
pTexture->setFilterMode( GLTexture::GLTextureFilterMode_NEAREST, GLTexture::GLTextureFilterMode_NEAREST );
return pTexture;
}
TexturePtr GLGraphicFactory::load2DTexture(const ResourcePtr& rsrc, bool generateMipmaps) const {
GLTexture2D* texture = new GLTexture2D();
if(texture->load(rsrc, generateMipmaps)) {
return TexturePtr(texture);
}
delete texture;
return TexturePtr();
}
GLTexture2DRenderView::GLTexture2DRenderView(const TexturePtr& texture, int32 index, int32 level):
mTexture(texture),
mLevel(level) {
GLTexture2D* glTexture = (GLTexture2D*)mTexture.get();
mTex = (GLuint)glTexture->getTextureId();
mWidth = glTexture->width(0);
mHeight = glTexture->height(0);
mIndex = index;
mElementFormat = glTexture->format();
}
TexturePtr GLGraphicFactory::create2DTexture(uint32 width,
uint32 height,
uint32 numMipmaps,
ElementFormat format,
const uint8* initialData,
uint32 flag) const {
GLTexture2D* texture = new GLTexture2D();
if(texture->create(width, height, numMipmaps, format, initialData)) {
return TexturePtr(texture);
}
delete texture;
return TexturePtr();
}
GLDepthStencilView::GLDepthStencilView(const TexturePtr& texture, int32 level):
mTexture(texture),
mLevel(level),
mRBO(0),
mSampleCount(1),
mSampleQuaility(1) {
GLTexture2D* glTexture = (GLTexture2D*)mTexture.get();
mTex = (GLuint)glTexture->getTextureId();
mWidth = glTexture->width(0);
mHeight = glTexture->height(0);
mElementFormat = glTexture->format();
CHECK_GL_CALL(glGenRenderbuffers(1, &mRBO));
if(mRBO) {
CHECK_GL_CALL(glBindRenderbuffer(GL_RENDERBUFFER, mRBO));
if(mSampleCount <= 1 || !glRenderbufferStorageMultisampleEXT) {
CHECK_GL_CALL(glRenderbufferStorage(GL_RENDERBUFFER, element_format_to_gl_format(mElementFormat), mWidth, mHeight));
}
else {
CHECK_GL_CALL(glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, mSampleCount, element_format_to_gl_format(mElementFormat), mWidth, mHeight));
}
}
}
/** Copy constructor. */
GLTexture2D::GLTexture2D(const GLTexture2D& rhs) : GLTexture2D(rhs.id, rhs.application)
{
if (rhs.IsLoaded()) GLTexture2D::Load();
}
bool EtoileGLMeshRenderPassPlugin::loadFile(const std::string& filename)
{
if(filename.empty()) return false;
std::string ext = File::getFileExtension(filename);
std::string path = File::getFilePath(filename);
TiXmlDocument doc(filename.c_str());
if(!doc.LoadFile())
{
std::cout << "erreur while loading: " << filename<<std::endl;
std::cout << "error #" << doc.ErrorId() << " : " << doc.ErrorDesc() << std::endl;
return false;
}
this->getInputSockets().clear();
this->addInputSocket(_pinputmesh);
this->addInputSocket(_pinputmeshunit);
if(_pview != NULL)
{
this->addInputSocket(_pview);
}
if(_pproj != NULL)
{
this->addInputSocket(_pproj);
}
if(_pviewproj != NULL)
{
this->addInputSocket(_pviewproj);
}
AABBWidget* aabbw = new AABBWidget();
aabbw->bindPass(this);
widget->addWidget(aabbw);
TiXmlHandle hdl(&doc);
TiXmlElement *elemRoot = hdl.FirstChildElement("Etoile").Element();
while (elemRoot)
{
TiXmlElement *passElement = elemRoot->FirstChildElement("MeshPass");
while (passElement)
{
std::string name = passElement->Attribute("name");
this->getType()._description = name;
int x;
if(TIXML_NO_ATTRIBUTE!=passElement->QueryIntAttribute("x", &x))
{
this->_x = x;
}
int y;
if(TIXML_NO_ATTRIBUTE!=passElement->QueryIntAttribute("y", &y))
{
this->_y = y;
}
int w;
if(TIXML_NO_ATTRIBUTE!=passElement->QueryIntAttribute("w", &w))
{
this->_w = w;
}
int h;
if(TIXML_NO_ATTRIBUTE!=passElement->QueryIntAttribute("h", &h))
{
this->_h = h;
}
initFBO();
TiXmlElement *gpuElement = passElement->FirstChildElement("GPU");
while (gpuElement)
{
const char* name = gpuElement->Attribute("name");
std::map<ShaderType, std::string> files;
TiXmlElement *vertexElement = gpuElement->FirstChildElement("vertex");
if(vertexElement != NULL)
{
const char* file = vertexElement->Attribute("file");
files[ShaderType::SHADERTYPE_VERTEX] = path + file;
}
TiXmlElement *fragElement = gpuElement->FirstChildElement("fragment");
if(fragElement != NULL)
{
const char* file = fragElement->Attribute("file");
files[SHADERTYPE_FRAGMENT] = path + file;
}
TiXmlElement *geometryElement = gpuElement->FirstChildElement("geometry");
if(geometryElement != NULL)
{
const char* file = geometryElement->Attribute("file");
files[SHADERTYPE_GEOMETRY] = path + file;
}
TiXmlElement *computeElement = gpuElement->FirstChildElement("compute");
if(computeElement != NULL)
{
const char* file = computeElement->Attribute("file");
files[SHADERTYPE_COMPUTE] = path + file;
}
TiXmlElement *tessCtrElement = gpuElement->FirstChildElement("tessctrl");
if(tessCtrElement != NULL)
{
const char* file = tessCtrElement->Attribute("file");
files[SHADERTYPE_TESSELLATION_CTRL] = path + file;
}
TiXmlElement *tessEvaElement = gpuElement->FirstChildElement("tesseval");
if(tessEvaElement != NULL)
{
const char* file = tessEvaElement->Attribute("file");
files[SHADERTYPE_TESSELLATION_EVAL] = path + file;
}
GLSLGpuProgram* glsl = new GLSLGpuProgram(name);
glsl->loadShaderFiles(files);
this->setCommonGpuProgram(glsl);
GpuCompileWidget* gwidget = new GpuCompileWidget();
gwidget->bindPass(this);
widget->addWidget(gwidget);
gpuElement = gpuElement->NextSiblingElement("GPU"); // iteration
}
TiXmlElement *outputsElement = passElement->FirstChildElement("Output");
while (outputsElement)
{
std::string type = outputsElement->Attribute("type");
std::string name = outputsElement->Attribute("name");
if(type.compare("texture2d")==0)
{
TextureRenderTarget* tt = new TextureRenderTarget(name);
GLTexture2D* t = new GLTexture2D(name);
t->create(w,h,1);
tt->set(t);
this->addOutputSocket(tt);
}
outputsElement = outputsElement->NextSiblingElement("Output"); // iteration
}
TiXmlElement *inputsElement = passElement->FirstChildElement("Input");
while (inputsElement)
{
std::string type = inputsElement->Attribute("type");
std::string name = inputsElement->Attribute("name");
if(type.compare("texture2d")==0)
{
EtoileMeshPassTextureInputSocket* in = new EtoileMeshPassTextureInputSocket(name);
this->addInputSocket(in);
}
else if(type.compare("float")==0)
{
EtoileMeshPassFloatInputSocket* in = new EtoileMeshPassFloatInputSocket(name);
in->setNode(this);
//this->addInputSocket(in);
FloatInputSocketWidget* socketwidget = new FloatInputSocketWidget(widget);
float value;
if(TIXML_NO_ATTRIBUTE!=inputsElement->QueryFloatAttribute("value", &value))
{
in->perform(&value);
}
socketwidget->bindParameter(in, value);
widget->addWidget(socketwidget);
}
else if(type.compare("int")==0)
{
EtoileMeshPassIntInputSocket* in = new EtoileMeshPassIntInputSocket(name);
in->setNode(this);
//this->addInputSocket(in);
IntInputSocketWidget* socketwidget = new IntInputSocketWidget(widget);
int value = 0;
if(TIXML_NO_ATTRIBUTE!=inputsElement->QueryIntAttribute("value", &value))
{
in->perform(&value);
}
socketwidget->bindParameter(in, value);
widget->addWidget(socketwidget);
}
inputsElement = inputsElement->NextSiblingElement("Input"); // iteration
}
passElement = passElement->NextSiblingElement("MeshPass"); // iteration
}
elemRoot = elemRoot->NextSiblingElement("Etoile"); // iteration
}
return true;
}
bool addImage(const GLTexture2D& texture, float scale = 1.f,
Vec2f* pMousePosInCanvas = nullptr) {
return addImage(texture, scale * texture.getWidth(), scale * texture.getHeight(),
pMousePosInCanvas);
}
/*
GL interop test.
Julia.
*/
TEST(GLInteropTest, Julia)
{
try
{
const int width = 1280;
const int height = 720;
const int bufWidth = 1920;
const int bufHeight = 1080;
// ------------------------------------------------------------
GLTestWindow window(width, height, true);
GLContextParam param;
param.DebugMode = true;
param.Multisample = 8;
GLContext context(window.Handle(), param);
GLUtil::EnableDebugOutput(GLUtil::DebugOutputFrequencyLow);
// ------------------------------------------------------------
// Choose device
cudaDeviceProp prop;
memset(&prop, 0, sizeof(cudaDeviceProp));
prop.major = 2;
prop.minor = 0;
int devID;
HandleCudaError(cudaChooseDevice(&devID, &prop));
HandleCudaError(cudaGLSetGLDevice(devID));
// Get properties
HandleCudaError(cudaGetDeviceProperties(&prop, devID));
// Create texture and PBO
GLTexture2D texture;
texture.SetMagFilter(GL_LINEAR);
texture.SetMinFilter(GL_LINEAR);
texture.SetWrap(GL_CLAMP_TO_EDGE);
texture.Allocate(bufWidth, bufHeight, GL_RGBA8);
GLPixelUnpackBuffer pbo;
pbo.Allocate(bufWidth * bufHeight * 4, NULL, GL_DYNAMIC_DRAW);
// Register
cudaGraphicsResource* cudaPbo;
HandleCudaError(cudaGraphicsGLRegisterBuffer(&cudaPbo, pbo.ID(), cudaGraphicsMapFlagsWriteDiscard));
// ------------------------------------------------------------
GLShader shader;
shader.Compile("../resources/texturetest_simple2d.vert");
shader.Compile("../resources/texturetest_simple2d.frag");
shader.Link();
GLVertexArray vao;
GLVertexBuffer positionVbo;
GLIndexBuffer ibo;
glm::vec3 v[] =
{
glm::vec3( 1.0f, 1.0f, 0.0f),
glm::vec3(-1.0f, 1.0f, 0.0f),
glm::vec3(-1.0f, -1.0f, 0.0f),
glm::vec3( 1.0f, -1.0f, 0.0f)
};
GLuint i[] =
{
0, 1, 2,
2, 3, 0
};
positionVbo.AddStatic(12, &v[0].x);
vao.Add(GLDefaultVertexAttribute::Position, &positionVbo);
ibo.AddStatic(6, i);
// ------------------------------------------------------------
double fps = 0.0;
double timeSum = 0.0;
double prevTime = GLTestUtil::CurrentTimeMilli();
int frameCount = 0;
double start = GLTestUtil::CurrentTimeMilli();
float xcparam = -0.8f;
float ycparam = 0.165f;
float inc = 0.001f;
while (window.ProcessEvent())
{
// ------------------------------------------------------------
double currentTime = GLTestUtil::CurrentTimeMilli();
double elapsedTime = currentTime - prevTime;
timeSum += elapsedTime;
frameCount++;
if (frameCount >= 13)
{
fps = 1000.0 * 13.0 / timeSum;
timeSum = 0.0;
frameCount = 0;
}
prevTime = currentTime;
window.SetTitle((boost::format("GLInteropTest_Julia [FPS %.1f]") % fps).str());
// ------------------------------------------------------------
double elapsed = GLTestUtil::CurrentTimeMilli() - start;
if (elapsed >= 1000.0)
{
break;
}
xcparam += inc;
if (xcparam > -0.799f || xcparam < -0.811f)
{
inc *= -1.0f;
}
// ------------------------------------------------------------
HandleCudaError(cudaGraphicsMapResources(1, &cudaPbo, NULL));
// Get device pointer
uchar4* devPtr;
size_t bufferSize;
HandleCudaError(cudaGraphicsResourceGetMappedPointer((void**)&devPtr, &bufferSize, cudaPbo));
Run_GLInteropTestJuliaKernel(bufWidth, bufHeight, prop.multiProcessorCount, xcparam, ycparam, devPtr);
HandleCudaError(cudaGraphicsUnmapResources(1, &cudaPbo, NULL));
texture.Replace(&pbo, glm::ivec4(0, 0, bufWidth, bufHeight), GL_RGBA, GL_UNSIGNED_BYTE);
// ------------------------------------------------------------
glClearBufferfv(GL_COLOR, 0, glm::value_ptr(glm::vec4(0.0f)));
glViewportIndexedfv(0, glm::value_ptr(glm::vec4(0, 0, width, height)));
shader.Begin();
shader.SetUniform("tex", 0);
texture.Bind();
vao.Draw(GL_TRIANGLES, &ibo);
texture.Unbind();
shader.End();
context.SwapBuffers();
}
cudaDeviceReset();
}
catch (const GLException& e)
{
FAIL() << GLTestUtil::PrintGLException(e);
}
}
/// Attaches a texture to the color attachment 0
void GLFramebuffer::attachTexture(const GLTexture2D& texture)
{
if(m_id == 0)
{
//Log("This is the default framebuffer");
return;
}
glBindFramebufferCGL(GL_FRAMEBUFFER_CGL, m_id);
glFramebufferTexture2DCGL(GL_FRAMEBUFFER_CGL, GL_COLOR_ATTACHMENT0_CGL, GL_TEXTURE_2D, texture.getIdentifier(), 0);
if(glCheckFramebufferStatusCGL(GL_FRAMEBUFFER_CGL) == GL_FRAMEBUFFER_COMPLETE_CGL)
{
//Log("Created a complete framebuffer");
}
}