LightSource::LightSource(LightShaderPair* shaders, int width, int height, int filter)
: enabled(true)
, mapShader(shaders->mapShader)
, renderShader(shaders->renderShader)
, occluderFBO(createFBO(width, height))
, shadowMapFBO(createFBO(width, 1))
, shadowRenderFBO(createFBO(width, height))
, position(0, 0)
, size((float)width, (float)height)
, offset(0, 0)
, color(sf::Color::Transparent)
, mask(nullptr)
, ownsMask(false)
, filterGroup(filter)
{ }
VolumeController::VolumeController( Renderer* renderer, const turok::VolumeDatasetCache* volume_dataset, const turok::uint64 gpuMem )
: m_renderer( renderer ),
m_shader( VolumeShader() ),
m_compaction_shader( CompactionShader() ),
m_corner1( 0 ),
m_node_tree_controller( NULL ),
m_show_volume_grid( false ),
m_fbo( 0 ),
m_fbo_depth_buffer( 0 ),
m_fbo_color_texture( NULL )
{
// create data structure manager
m_node_tree_controller = new NodeTreeController( volume_dataset, gpuMem );
// get values for shader
unsigned int lod_count = m_node_tree_controller->getLODCount();
float sampling_factor = 1.25f;
//dvec3 full_resolution_dataset_size = m_node_tree_controller->getFullResolutionDatasetSizeVoxels().castType< double >(); // TODO: make these uivec3
//full_resolution_dataset_size.setAllValues( full_resolution_dataset_size.max() );
/*uint max_blocks = volume_dataset->getLODInfo( 0 ).size_blocks.max();
max_blocks = ( ( max_blocks + 1 ) & ~1 );*/ // make this power of 2?
uint max_blocks = volume_dataset->getLODInfo( 0 ).size_blocks.max();
// calculate power of 2 block size
uint pow2_max_blocks = 1;
while( pow2_max_blocks < max_blocks ) {
pow2_max_blocks <<= 1;
}
dvec3 actual_dataset_size = volume_dataset->getLODInfo( 0 ).size_blocks.castType< double >() * ( BLOCK_EDGE_LENGTH - 2 * BLOCK_OVERLAP );
dvec3 full_resolution_dataset_size;
full_resolution_dataset_size.setAllValues( pow2_max_blocks * ( BLOCK_EDGE_LENGTH - 2 * BLOCK_OVERLAP ) );
dvec3 block_size;
block_size.setAllValues( static_cast< double >( m_node_tree_controller->getBlockSizeVoxels() ) );
dvec3 block_pool_texture_size = m_node_tree_controller->getBlockPoolTextureSize().castType< double >();
dvec3 node_pool_texture_size = m_node_tree_controller->getNodePoolTextureSize().castType< double >();
// set geometric size
// use actual size here to stop rays from being cast through padded space (no pixel rasterized = no rays)
m_corner2 = actual_dataset_size; //m_node_tree_controller->getFullResolutionDatasetSize();
m_axis_aligned_bounding_box = AxisAlignedBoundingBox( m_corner1, m_corner2 );
// setup shader
m_shader.setBlockPoolTexture( 0 ); // GL_TEXTURE0
m_shader.setNodePoolTexture( 1 ); // GL_TEXTURE1
m_shader.setLODCount( lod_count );
m_shader.setMaxLOD( 0 );
m_shader.setSamplingFactor( sampling_factor );
m_shader.setGeometricSize( full_resolution_dataset_size ); // TODO: what if m_corner1 isn't at the origin?
m_shader.setBlockSize( block_size );
m_shader.setFullResolutionDatasetSize( full_resolution_dataset_size );
m_shader.setBlockPoolTextureSize( block_pool_texture_size );
m_shader.setNodePoolTextureSize( node_pool_texture_size );
m_shader.setNormalizedViewDir( Normalize( m_renderer->getCamera()->getDirection() ) );
m_compaction_shader.setColorTexture( 0 ); // GL_TEXTURE0
createFBO();
}
void Window::bindContentFBO()
{
if (m_resized || !m_contentFBO) {
createFBO();
}
m_contentFBO->bind();
}
GRendering::GRendering(GSceneManager* p_sceneManager)
{
initGLSL();
sm_sceneMgr = p_sceneManager;
createFBO();
}
void init()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10, 10, -10, 10, -10, 10);
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
//createTexture();
createFBO(render_option);
}
bool RGBShift::setup() {
if(!createFBO()) {
return false;
}
if(!createShader()) {
return false;
}
glGenVertexArrays(1, &vao);;
return true;
}
bool Canvas::loadVolatile()
{
status = createFBO(fbo, depth_stencil, img, width, height);
if (status != GL_FRAMEBUFFER_COMPLETE)
return false;
setFilter(settings.filter);
setWrap(settings.wrap);
Color c;
c.r = c.g = c.b = c.a = 0;
clear(c);
return true;
}
void AppManager::init(){
/* Initialize the library */
if (glfwInit() != GL_TRUE) {
THROW_EXCEPTION("Failed to initialize GLFW");
}
glfwSetErrorCallback(error_callback);
createOpenGLContext();
setOpenGLStates();
createFBO();
createProgram();
createVAO();
applyInitial();
}
void textArea::build() {
textBlock.init(fontName, fontSize);
textBlock.setText(textContent);
ofFbo::Settings fboSettings;
fboSettings.internalformat = GL_RGBA32F_ARB;
fboSettings.useDepth = true;
fboSettings.useStencil = true;
fboSettings.textureTarget = GL_TEXTURE_2D;
fboSettings.width = width;
fboSettings.height = height;
fboSettings.numSamples = 2;
fbo.allocate(fboSettings);
createFBO();
}
bool GLWidgetRenderStrategy::render(Content* content, Image* renderImage)
{
if (!renderImage)
return false;
glWidget->makeCurrent();
QSize size(renderImage->width(), renderImage->height());
createFBO(size);
// Render frame into QGLWidget.
// This isn't really valid for a hidden QGLWidget due to the OpenGL
// "pixel ownership test". But it works with some graphics drivers.
fbo->bind();
glClear(GL_COLOR_BUFFER_BIT);
QPainter painter(fbo);
painter.translate(0, size.height());
painter.scale(1, -1);
painter.setRenderHints(QPainter::Antialiasing |
QPainter::TextAntialiasing |
QPainter::SmoothPixmapTransform, true);
content->paintContent(&painter);
painter.end();
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
if (renderImage->hasAlpha()) {
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glReadPixels(0, 0, renderImage->width(), renderImage->height(),
GL_RGBA, GL_UNSIGNED_BYTE, renderImage->pixels());
}
else {
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 3);
glReadPixels(0, 0, renderImage->width(), renderImage->height(),
GL_RGB, GL_UNSIGNED_BYTE, renderImage->pixels());
}
glPopClientAttrib();
fbo->release();
glWidget->doneCurrent();
return true;
}
////////////////////////////////////////////////////////////////////////////////
//! Run a simple test for CUDA
////////////////////////////////////////////////////////////////////////////////
void
runTest( int argc, char** argv) {
// Create GL context
glutInit( &argc, argv);
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE);
glutInitWindowSize( window_width, window_height);
glutCreateWindow( "CUDA OpenGL post-processing");
// initialize GL
if( CUTFalse == initGL()) {
return;
}
// register callbacks
glutDisplayFunc( display);
glutKeyboardFunc( keyboard);
glutReshapeFunc( reshape);
glutIdleFunc( idle);
// create menu
glutCreateMenu(mainMenu);
glutAddMenuEntry("Toggle CUDA processing [ ]", ' ');
glutAddMenuEntry("Toggle animation [a]", 'a');
glutAddMenuEntry("Increment blur radius [=]", '=');
glutAddMenuEntry("Decrement blur radius [-]", '-');
glutAddMenuEntry("Quit (esc)", '\033');
glutAttachMenu(GLUT_RIGHT_BUTTON);
// create pbo
createPBO( &pbo_source);
createPBO( &pbo_dest);
// create fbo
createFBO( &fbo, &tex_fbo);
// create texture for blitting onto the screen
createTexture( &tex_screen, image_width, image_height);
// start rendering mainloop
glutMainLoop();
}
void DVWindow::updateQmlSize() {
qmlSize = size();
/* If Side-by-Side and not anamorphic we only render QML at half of the window size (horizontally). */
if(qmlCommunication->drawMode() == DVDrawMode::SidebySide && !qmlCommunication->anamorphicDualView())
qmlSize.setWidth(qmlSize.width() / 2);
/* If Top/Bottom and not anamorphic we only render QML at half of the window size (vertically). */
if(qmlCommunication->drawMode() == DVDrawMode::TopBottom && !qmlCommunication->anamorphicDualView())
qmlSize.setHeight(qmlSize.height() / 2);
if (qmlCommunication->drawMode() == DVDrawMode::Plugin)
getPluginSize();
/* Don't recreate fbo's unless they are null or size is wrong. */
if(renderFBO == nullptr || renderFBO->size() != qmlSize)
createFBO();
qmlRoot->setSize(qmlSize);
qmlWindow->setGeometry(QRect(QPoint(), qmlSize));
}
bool GLWidgetRenderStrategy::render(Content* content, Image* renderImage)
{
if (!renderImage)
return false;
glWidget->makeCurrent();
QSize size(renderImage->width(), renderImage->height());
createFBO(size);
// Render frame into QGLWidget.
// This isn't really valid for a hidden QGLWidget due to the OpenGL
// "pixel ownership test". But it works with some graphics drivers.
QPainter painter(glWidget);
painter.setRenderHints(QPainter::Antialiasing |
QPainter::TextAntialiasing |
QPainter::SmoothPixmapTransform, true);
content->paintContent(&painter);
painter.end();
// Blit from QGLWidget to FBO, flipping image vertically
QRect srcRect(0, 0, renderImage->width(), renderImage->height());
QRect dstRect(0, renderImage->height(),
renderImage->width(), -renderImage->height());
QGLFramebufferObject::blitFramebuffer(fbo, srcRect, 0, dstRect);
// Read back the pixels from the FBO
fbo->bind();
glPushClientAttrib(GL_CLIENT_PIXEL_STORE_BIT);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_ROW_LENGTH, renderImage->bytesPerLine() / 3);
glReadPixels(0, 0, renderImage->width(), renderImage->height(),
GL_RGB, GL_UNSIGNED_BYTE, renderImage->pixels());
glPopClientAttrib();
fbo->release();
glWidget->doneCurrent();
return true;
}
