void VolumeMaxCLProcessor::executeVolumeOperation(const Volume* volume,
const VolumeCLBase* volumeCL,
VolumeCLBase* volumeOutCL, const size3_t& outDim,
const size3_t& globalWorkGroupSize,
const size3_t& localWorkgroupSize) {
cl::Event events[2];
try {
BufferCL* tmpVolumeCL;
int argIndex = 0;
kernel_->setArg(argIndex++, *volumeCL);
kernel_->setArg(argIndex++,
*(volumeCL->getVolumeStruct(volume)
.getRepresentation<BufferCL>())); // Scaling for 12-bit data
if (supportsVolumeWrite_) {
kernel_->setArg(argIndex++, *volumeOutCL);
} else {
size_t outDimFlattened = outDim.x * outDim.y * outDim.z;
if (tmpVolume_ == nullptr || tmpVolume_->getSize() != outDimFlattened) {
delete tmpVolume_;
tmpVolume_ = new Buffer<unsigned char>(outDimFlattened);
}
tmpVolumeCL = tmpVolume_->getEditableRepresentation<BufferCL>();
kernel_->setArg(argIndex++, *tmpVolumeCL);
}
kernel_->setArg(argIndex++, ivec4(outDim, 0));
kernel_->setArg(argIndex++, ivec4(volumeRegionSize_.get()));
OpenCL::getPtr()->getQueue().enqueueNDRangeKernel(
*kernel_, cl::NullRange, globalWorkGroupSize, localWorkgroupSize, nullptr, &events[0]);
if (!supportsVolumeWrite_) {
std::vector<cl::Event> waitFor(1, events[0]);
OpenCL::getPtr()->getQueue().enqueueCopyBufferToImage(
tmpVolumeCL->get(), volumeOutCL->getEditable(), 0, size3_t(0), size3_t(outDim),
&waitFor, &events[1]);
}
} catch (cl::Error& err) {
LogError(getCLErrorString(err));
}
#if IVW_PROFILING
try {
if (supportsVolumeWrite_) {
events[0].wait();
LogInfo("Exec time: " << events[0].getElapsedTime() << " ms");
} else {
// Measure both computation and copy (only need to wait for copy)
events[1].wait();
LogInfo("Exec time (computation, copy): "
<< events[0].getElapsedTime() << " + " << events[1].getElapsedTime() << " = "
<< events[0].getElapsedTime() + events[1].getElapsedTime() << " ms");
}
} catch (cl::Error& err) {
LogError(getCLErrorString(err));
}
#endif
}
QtCanvas::QtCanvas(const std::string& title,
const ivec2& size,
const Buffers buffers,
QWidget* parent, bool shared, Qt::WFlags f, char* /*name*/)
: GLCanvas(title, size, buffers)
, QGLWidget(getQGLFormat(buffers), parent, (shared ? shareWidget_ : 0), f)
{
resize(size.x, size.y);
if (shared && shareWidget_ == 0)
shareWidget_ = this;
setWindowTitle(QString(title.c_str()));
setFocusPolicy(Qt::StrongFocus);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
// we have our own AutoBufferSwap-mechanism (GLCanvas::setAutoFlush), so disable the one of qt
setAutoBufferSwap(false);
rgbaSize_ = ivec4(format().redBufferSize(),
format().greenBufferSize(),
format().blueBufferSize(),
format().alphaBufferSize());
stencilSize_ = format().stencilBufferSize();
depthSize_ = format().depthBufferSize();
doubleBuffered_ = doubleBuffer();
stereoViewing_ = format().stereo();
}
void TestWindow::resizeWindow(const QSize& size) {
_size = size;
_renderArgs->_viewport = ivec4(0, 0, _size.width(), _size.height());
auto fboCache = DependencyManager::get<FramebufferCache>();
if (fboCache) {
fboCache->setFrameBufferSize(_size);
}
}
//-----------------------------------------------------------------------------
void Region::SetupScreen( int width, int height ) {
m_computed_rect = ivec4( 0, 0, width, height );
m_computed_valid = true;
m_computed_strata = StrataBase( Strata::BACKGROUND );
m_computed_size = ivec2( width, height );
for( auto r : m_anchor_list ) {
r->Compute();
}
}
void main(void) {
if ( int(vDiscard + 0.5) != 0) discard;
if (ivec4(uClippingPlane + 0.5) != ivec4(0, 0, 0, 0))
{
//clipping test
vec4 p = uClippingPlane;
vec3 x = vPosition;
float distance = (p.x * x.x + p.y * x.y + p.z * x.z + p.w) / sqrt(p.x * p.x + p.y * p.y + p.z * p.z);
if (int(distance + 0.5) < 0){
discard;
}
}
//fix wrong normals
//gl_FragColor = gl_FrontFacing ? vFrontColor : vBackColor;
//gl_FragColor = vBackColor;
gl_FragColor = vFrontColor;
}
QtCanvas::QtCanvas(QWidget* parent, bool shared, Qt::WFlags f, char* /*name*/)
: GLCanvas()
, QGLWidget(parent, (shared ? shareWidget_ : 0), f)
{
if (shared && shareWidget_ == 0)
shareWidget_ = this;
// we have our own AutoBufferSwap-mechanism (GLCanvas::setAutoFlush), so disable the one of qt
setAutoBufferSwap(false);
rgbaSize_ = ivec4(format().redBufferSize(),
format().greenBufferSize(),
format().blueBufferSize(),
format().alphaBufferSize());
stencilSize_ = format().stencilBufferSize();
depthSize_ = format().depthBufferSize();
doubleBuffered_ = doubleBuffer();
stereoViewing_ = format().stereo();
}
void GLUTCanvas::init() {
glutInitDisplayMode(getDisplayMode());
atexit(onExitFunction); // FIXME: sholdn't this be part of GLUTApplication??
glutInitWindowSize(size_.x, size_.y);
glutCreateWindow(title_.c_str());
windowID_ = glutGetWindow();
Canvases_[windowID_] = this;
registerCallbacks();
rgbaSize_ = ivec4(glutGet(GLUT_WINDOW_RED_SIZE),
glutGet(GLUT_WINDOW_GREEN_SIZE),
glutGet(GLUT_WINDOW_BLUE_SIZE),
glutGet(GLUT_WINDOW_ALPHA_SIZE)) ;
stencilSize_ = glutGet(GLUT_WINDOW_STENCIL_SIZE);
depthSize_ = glutGet(GLUT_WINDOW_DEPTH_SIZE);
doubleBuffered_ = (0 != glutGet(GLUT_WINDOW_DOUBLEBUFFER));
stereoViewing_ = (0 != glutGet(GLUT_WINDOW_STEREO));
GLCanvas::init();
}
int main()
{
void (*pfi)( int ) = print_elements;
int ia1[6] = { 1,3,5,7,9,12 };
int ia2[8] = { 0,1,1,2,3,5,8,13 };
int ia3[3] = { 1,3,9 };
int ia4[4] = { 1,3,5,7 };
int ia5[2] = { 2,4 };
vector<int> ivec1( ia1, ia1+6 );
vector<int> ivec2( ia2, ia2+8 );
vector<int> ivec3( ia3, ia3+3 );
vector<int> ivec4( ia4, ia4+4 );
vector<int> ivec5( ia5, ia5+2 );
cout << "ivec1: "; for_each( ivec1.begin(), ivec1.end(), pfi ); cout << "\n";
cout << "ivec2: "; for_each( ivec2.begin(), ivec2.end(), pfi ); cout << "\n";
cout << "ivec3: "; for_each( ivec3.begin(), ivec3.end(), pfi ); cout << "\n";
cout << "ivec4: "; for_each( ivec4.begin(), ivec4.end(), pfi ); cout << "\n";
cout << "ivec5: "; for_each( ivec5.begin(), ivec5.end(), pfi ); cout << "\n\n";
cout << "ivec1 < ivec2 " << (ivec1 < ivec2 ? "true" : "false") << "\n";
cout << "ivec2 < ivec1 " << (ivec2 < ivec1 ? "true" : "false") << "\n\n";
cout << "ivec1 < ivec3 " << (ivec1 < ivec3 ? "true" : "false") << "\n";
cout << "ivec1 < ivec4 " << (ivec1 < ivec4 ? "true" : "false") << "\n";
cout << "ivec1 < ivec5 " << (ivec1 < ivec5 ? "true" : "false") << "\n\n";
cout << "ivec1 == ivec1 " << (ivec1 == ivec1 ? "true" : "false") << "\n";
cout << "ivec1 == ivec4 " << (ivec1 == ivec4 ? "true" : "false") << "\n";
cout << "ivec1 != ivec4 " << (ivec1 != ivec4 ? "true" : "false") << "\n\n";
cout << "ivec1 > ivec2 " << (ivec1 > ivec2 ? "true" : "false") << "\n";
cout << "ivec3 > ivec1 " << (ivec3 > ivec1 ? "true" : "false") << "\n";
cout << "ivec5 > ivec2 " << (ivec5 > ivec2 ? "true" : "false") << "\n";
}
void DeferredLightingEffect::render(const render::RenderContextPointer& renderContext) {
auto args = renderContext->args;
gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
// Allocate the parameters buffer used by all the deferred shaders
if (!_deferredTransformBuffer[0]._buffer) {
DeferredTransform parameters;
_deferredTransformBuffer[0] = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(DeferredTransform), (const gpu::Byte*) ¶meters));
_deferredTransformBuffer[1] = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(DeferredTransform), (const gpu::Byte*) ¶meters));
}
// Framebuffer copy operations cannot function as multipass stereo operations.
batch.enableStereo(false);
// perform deferred lighting, rendering to free fbo
auto framebufferCache = DependencyManager::get<FramebufferCache>();
auto textureCache = DependencyManager::get<TextureCache>();
QSize framebufferSize = framebufferCache->getFrameBufferSize();
// binding the first framebuffer
auto lightingFBO = framebufferCache->getLightingFramebuffer();
batch.setFramebuffer(lightingFBO);
batch.setViewportTransform(args->_viewport);
batch.setStateScissorRect(args->_viewport);
// Bind the G-Buffer surfaces
batch.setResourceTexture(DEFERRED_BUFFER_COLOR_UNIT, framebufferCache->getDeferredColorTexture());
batch.setResourceTexture(DEFERRED_BUFFER_NORMAL_UNIT, framebufferCache->getDeferredNormalTexture());
batch.setResourceTexture(DEFERRED_BUFFER_EMISSIVE_UNIT, framebufferCache->getDeferredSpecularTexture());
batch.setResourceTexture(DEFERRED_BUFFER_DEPTH_UNIT, framebufferCache->getPrimaryDepthTexture());
// FIXME: Different render modes should have different tasks
if (args->_renderMode == RenderArgs::DEFAULT_RENDER_MODE && _ambientOcclusionEnabled) {
batch.setResourceTexture(DEFERRED_BUFFER_OBSCURANCE_UNIT, framebufferCache->getOcclusionTexture());
} else {
// need to assign the white texture if ao is off
batch.setResourceTexture(DEFERRED_BUFFER_OBSCURANCE_UNIT, textureCache->getWhiteTexture());
}
assert(_lightStage.lights.size() > 0);
const auto& globalShadow = _lightStage.lights[0]->shadow;
// Bind the shadow buffer
batch.setResourceTexture(SHADOW_MAP_UNIT, globalShadow.map);
// THe main viewport is assumed to be the mono viewport (or the 2 stereo faces side by side within that viewport)
auto monoViewport = args->_viewport;
float sMin = args->_viewport.x / (float)framebufferSize.width();
float sWidth = args->_viewport.z / (float)framebufferSize.width();
float tMin = args->_viewport.y / (float)framebufferSize.height();
float tHeight = args->_viewport.w / (float)framebufferSize.height();
// The view frustum is the mono frustum base
auto viewFrustum = args->_viewFrustum;
// Eval the mono projection
mat4 monoProjMat;
viewFrustum->evalProjectionMatrix(monoProjMat);
// The mono view transform
Transform monoViewTransform;
viewFrustum->evalViewTransform(monoViewTransform);
// THe mono view matrix coming from the mono view transform
glm::mat4 monoViewMat;
monoViewTransform.getMatrix(monoViewMat);
// Running in stero ?
bool isStereo = args->_context->isStereo();
int numPasses = 1;
mat4 projMats[2];
Transform viewTransforms[2];
ivec4 viewports[2];
vec4 clipQuad[2];
vec2 screenBottomLeftCorners[2];
vec2 screenTopRightCorners[2];
vec4 fetchTexcoordRects[2];
DeferredTransform deferredTransforms[2];
auto geometryCache = DependencyManager::get<GeometryCache>();
if (isStereo) {
numPasses = 2;
mat4 eyeViews[2];
args->_context->getStereoProjections(projMats);
args->_context->getStereoViews(eyeViews);
float halfWidth = 0.5f * sWidth;
for (int i = 0; i < numPasses; i++) {
// In stereo, the 2 sides are layout side by side in the mono viewport and their width is half
int sideWidth = monoViewport.z >> 1;
viewports[i] = ivec4(monoViewport.x + (i * sideWidth), monoViewport.y, sideWidth, monoViewport.w);
deferredTransforms[i].projection = projMats[i];
auto sideViewMat = monoViewMat * glm::inverse(eyeViews[i]);
viewTransforms[i].evalFromRawMatrix(sideViewMat);
deferredTransforms[i].viewInverse = sideViewMat;
deferredTransforms[i].stereoSide = (i == 0 ? -1.0f : 1.0f);
clipQuad[i] = glm::vec4(sMin + i * halfWidth, tMin, halfWidth, tHeight);
screenBottomLeftCorners[i] = glm::vec2(-1.0f + i * 1.0f, -1.0f);
screenTopRightCorners[i] = glm::vec2(i * 1.0f, 1.0f);
fetchTexcoordRects[i] = glm::vec4(sMin + i * halfWidth, tMin, halfWidth, tHeight);
}
} else {
viewports[0] = monoViewport;
projMats[0] = monoProjMat;
deferredTransforms[0].projection = monoProjMat;
deferredTransforms[0].viewInverse = monoViewMat;
viewTransforms[0] = monoViewTransform;
deferredTransforms[0].stereoSide = 0.0f;
clipQuad[0] = glm::vec4(sMin, tMin, sWidth, tHeight);
screenBottomLeftCorners[0] = glm::vec2(-1.0f, -1.0f);
screenTopRightCorners[0] = glm::vec2(1.0f, 1.0f);
fetchTexcoordRects[0] = glm::vec4(sMin, tMin, sWidth, tHeight);
}
auto eyePoint = viewFrustum->getPosition();
float nearRadius = glm::distance(eyePoint, viewFrustum->getNearTopLeft());
for (int side = 0; side < numPasses; side++) {
// Render in this side's viewport
batch.setViewportTransform(viewports[side]);
batch.setStateScissorRect(viewports[side]);
// Sync and Bind the correct DeferredTransform ubo
_deferredTransformBuffer[side]._buffer->setSubData(0, sizeof(DeferredTransform), (const gpu::Byte*) &deferredTransforms[side]);
batch.setUniformBuffer(_directionalLightLocations->deferredTransformBuffer, _deferredTransformBuffer[side]);
glm::vec2 topLeft(-1.0f, -1.0f);
glm::vec2 bottomRight(1.0f, 1.0f);
glm::vec2 texCoordTopLeft(clipQuad[side].x, clipQuad[side].y);
glm::vec2 texCoordBottomRight(clipQuad[side].x + clipQuad[side].z, clipQuad[side].y + clipQuad[side].w);
// First Global directional light and ambient pass
{
auto& program = _shadowMapEnabled ? _directionalLightShadow : _directionalLight;
LightLocationsPtr locations = _shadowMapEnabled ? _directionalLightShadowLocations : _directionalLightLocations;
const auto& keyLight = _allocatedLights[_globalLights.front()];
// Setup the global directional pass pipeline
{
if (_shadowMapEnabled) {
if (keyLight->getAmbientMap()) {
program = _directionalSkyboxLightShadow;
locations = _directionalSkyboxLightShadowLocations;
} else {
program = _directionalAmbientSphereLightShadow;
locations = _directionalAmbientSphereLightShadowLocations;
}
} else {
if (keyLight->getAmbientMap()) {
program = _directionalSkyboxLight;
locations = _directionalSkyboxLightLocations;
} else {
program = _directionalAmbientSphereLight;
locations = _directionalAmbientSphereLightLocations;
}
}
if (locations->shadowTransformBuffer >= 0) {
batch.setUniformBuffer(locations->shadowTransformBuffer, globalShadow.getBuffer());
}
batch.setPipeline(program);
}
{ // Setup the global lighting
setupKeyLightBatch(batch, locations->lightBufferUnit, SKYBOX_MAP_UNIT);
}
{
batch.setModelTransform(Transform());
batch.setProjectionTransform(glm::mat4());
batch.setViewTransform(Transform());
glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
geometryCache->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
}
if (keyLight->getAmbientMap()) {
batch.setResourceTexture(SKYBOX_MAP_UNIT, nullptr);
}
}
auto texcoordMat = glm::mat4();
/* texcoordMat[0] = glm::vec4(sWidth / 2.0f, 0.0f, 0.0f, sMin + sWidth / 2.0f);
texcoordMat[1] = glm::vec4(0.0f, tHeight / 2.0f, 0.0f, tMin + tHeight / 2.0f);
*/ texcoordMat[0] = glm::vec4(fetchTexcoordRects[side].z / 2.0f, 0.0f, 0.0f, fetchTexcoordRects[side].x + fetchTexcoordRects[side].z / 2.0f);
texcoordMat[1] = glm::vec4(0.0f, fetchTexcoordRects[side].w / 2.0f, 0.0f, fetchTexcoordRects[side].y + fetchTexcoordRects[side].w / 2.0f);
texcoordMat[2] = glm::vec4(0.0f, 0.0f, 1.0f, 0.0f);
texcoordMat[3] = glm::vec4(0.0f, 0.0f, 0.0f, 1.0f);
// enlarge the scales slightly to account for tesselation
const float SCALE_EXPANSION = 0.05f;
batch.setProjectionTransform(projMats[side]);
batch.setViewTransform(viewTransforms[side]);
// Splat Point lights
if (!_pointLights.empty()) {
batch.setPipeline(_pointLight);
batch._glUniformMatrix4fv(_pointLightLocations->texcoordMat, 1, false, reinterpret_cast< const float* >(&texcoordMat));
for (auto lightID : _pointLights) {
auto& light = _allocatedLights[lightID];
// IN DEBUG: light->setShowContour(true);
batch.setUniformBuffer(_pointLightLocations->lightBufferUnit, light->getSchemaBuffer());
float expandedRadius = light->getMaximumRadius() * (1.0f + SCALE_EXPANSION);
// TODO: We shouldn;t have to do that test and use a different volume geometry for when inside the vlight volume,
// we should be able to draw thre same geometry use DepthClamp but for unknown reason it's s not working...
if (glm::distance(eyePoint, glm::vec3(light->getPosition())) < expandedRadius + nearRadius) {
Transform model;
model.setTranslation(glm::vec3(0.0f, 0.0f, -1.0f));
batch.setModelTransform(model);
batch.setViewTransform(Transform());
batch.setProjectionTransform(glm::mat4());
glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
batch.setProjectionTransform(projMats[side]);
batch.setViewTransform(viewTransforms[side]);
} else {
Transform model;
model.setTranslation(glm::vec3(light->getPosition().x, light->getPosition().y, light->getPosition().z));
batch.setModelTransform(model.postScale(expandedRadius));
batch._glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
geometryCache->renderSphere(batch);
}
}
}
// Splat spot lights
if (!_spotLights.empty()) {
batch.setPipeline(_spotLight);
batch._glUniformMatrix4fv(_spotLightLocations->texcoordMat, 1, false, reinterpret_cast< const float* >(&texcoordMat));
for (auto lightID : _spotLights) {
auto light = _allocatedLights[lightID];
// IN DEBUG: light->setShowContour(true);
batch.setUniformBuffer(_spotLightLocations->lightBufferUnit, light->getSchemaBuffer());
auto eyeLightPos = eyePoint - light->getPosition();
auto eyeHalfPlaneDistance = glm::dot(eyeLightPos, light->getDirection());
const float TANGENT_LENGTH_SCALE = 0.666f;
glm::vec4 coneParam(light->getSpotAngleCosSin(), TANGENT_LENGTH_SCALE * tanf(0.5f * light->getSpotAngle()), 1.0f);
float expandedRadius = light->getMaximumRadius() * (1.0f + SCALE_EXPANSION);
// TODO: We shouldn;t have to do that test and use a different volume geometry for when inside the vlight volume,
// we should be able to draw thre same geometry use DepthClamp but for unknown reason it's s not working...
if ((eyeHalfPlaneDistance > -nearRadius) &&
(glm::distance(eyePoint, glm::vec3(light->getPosition())) < expandedRadius + nearRadius)) {
coneParam.w = 0.0f;
batch._glUniform4fv(_spotLightLocations->coneParam, 1, reinterpret_cast< const float* >(&coneParam));
Transform model;
model.setTranslation(glm::vec3(0.0f, 0.0f, -1.0f));
batch.setModelTransform(model);
batch.setViewTransform(Transform());
batch.setProjectionTransform(glm::mat4());
glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
batch.setProjectionTransform( projMats[side]);
batch.setViewTransform(viewTransforms[side]);
} else {
coneParam.w = 1.0f;
batch._glUniform4fv(_spotLightLocations->coneParam, 1, reinterpret_cast< const float* >(&coneParam));
Transform model;
model.setTranslation(light->getPosition());
model.postRotate(light->getOrientation());
model.postScale(glm::vec3(expandedRadius, expandedRadius, expandedRadius));
batch.setModelTransform(model);
auto mesh = getSpotLightMesh();
batch.setIndexBuffer(mesh->getIndexBuffer());
batch.setInputBuffer(0, mesh->getVertexBuffer());
batch.setInputFormat(mesh->getVertexFormat());
auto& part = mesh->getPartBuffer().get<model::Mesh::Part>();
batch.drawIndexed(model::Mesh::topologyToPrimitive(part._topology), part._numIndices, part._startIndex);
}
}
}
}
// Probably not necessary in the long run because the gpu layer would unbound this texture if used as render target
batch.setResourceTexture(DEFERRED_BUFFER_COLOR_UNIT, nullptr);
batch.setResourceTexture(DEFERRED_BUFFER_NORMAL_UNIT, nullptr);
batch.setResourceTexture(DEFERRED_BUFFER_EMISSIVE_UNIT, nullptr);
batch.setResourceTexture(DEFERRED_BUFFER_DEPTH_UNIT, nullptr);
batch.setResourceTexture(DEFERRED_BUFFER_OBSCURANCE_UNIT, nullptr);
batch.setResourceTexture(SHADOW_MAP_UNIT, nullptr);
batch.setResourceTexture(SKYBOX_MAP_UNIT, nullptr);
batch.setUniformBuffer(_directionalLightLocations->deferredTransformBuffer, nullptr);
});
ivec4 operator-() const
{
return ivec4(-x(), -y(), -z(), -w());
}
ivec4 toGlm(const QRect& rect) {
return ivec4(rect.x(), rect.y(), rect.width(), rect.height());
}
ivec4 operator-(GLint f) const
{
return ivec4(x()-f, y()-f, z()-f, w()-f);
}
void setClearColorInt(int r, int g, int b, int a) { mClearColorInt = ivec4(r,g,b,a); }
ivec4 operator/(GLint f) const
{
return ivec4(x()/f, y()/f, z()/f, w()/f);
}
SystemSettings::SystemSettings()
: Settings("System Settings")
, applicationUsageModeProperty_("applicationUsageMode", "Application usage mode")
, poolSize_("poolSize", "Pool Size", 4, 0, 32)
, txtEditorProperty_("txtEditor", "Use system text editor", true)
, enablePortInformationProperty_("enablePortInformation", "Enable port information", true)
, enablePortInspectorsProperty_("enablePortInspectors", "Enable port inspectors", true)
, portInspectorSize_("portInspectorSize", "Port inspector size", 128, 1, 1024)
, enablePickingProperty_("enablePicking", "Enable picking", true)
, enableSoundProperty_("enableSound", "Enable sound", true)
, useRAMPercentProperty_("useRAMPercent", "Max memory usage (%)", 50, 1, 100)
, logStackTraceProperty_("logStackTraceProperty", "Error stack trace log", false)
, btnAllocTestProperty_("allocTest", "Perform Allocation Test")
, btnSysInfoProperty_("printSysInfo", "Print System Info")
, glslSyntax_("glslSyntax", "GLSL Syntax Highlighting")
, glslTextColor_("glslTextColor", "Text", ivec4(0xAA, 0xAA, 0xAA, 255), ivec4(0, 0, 0, 1),
ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1), InvalidationLevel::InvalidOutput,
PropertySemantics::Color)
, glslBackgroundColor_("glslBackgroundColor", "Background", ivec4(0x4D, 0x4D, 0x4D, 255),
ivec4(0, 0, 0, 1), ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslQualifierColor_("glslQualifierColor", "Qualifiers", ivec4(0x7D, 0xB4, 0xDF, 255),
ivec4(0, 0, 0, 1), ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslBuiltinsColor_("glslBultinsColor", "Builtins", ivec4(0x1F, 0xF0, 0x7F, 255),
ivec4(0, 0, 0, 1), ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslTypeColor_("glslTypeColor", "Types", ivec4(0x56, 0x9C, 0xD6, 255), ivec4(0, 0, 0, 1),
ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1), InvalidationLevel::InvalidOutput,
PropertySemantics::Color)
, glslGlslBuiltinsColor_("glslGlslBultinsColor", "GLSL Builtins", ivec4(0xFF, 0x80, 0x00, 255),
ivec4(0, 0, 0, 1), ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslCommentColor_("glslCommentColor", "Comments", ivec4(0x60, 0x8B, 0x4E, 255),
ivec4(0, 0, 0, 1), ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, glslPreProcessorColor_("glslPreProcessorColor", "Pre Processor", ivec4(0x9B, 0x9B, 0x9B, 255),
ivec4(0, 0, 0, 1), ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, pythonSyntax_("pythonSyntax_", "Python Syntax Highlighting")
, pyFontSize_("pyFontSize_" , "Font Size" , 11 , 1, 72)
, pyBGColor_("pyBGColor", "Background", ivec4(0xb0, 0xb0, 0xbc, 255), ivec4(0, 0, 0, 1),
ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1), InvalidationLevel::InvalidOutput,
PropertySemantics::Color)
, pyTextColor_("pyTextColor", "Text", ivec4(0x11, 0x11, 0x11, 255), ivec4(0, 0, 0, 1),
ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1), InvalidationLevel::InvalidOutput,
PropertySemantics::Color)
, pyTypeColor_("pyTypeColor", "Types", ivec4(0x14, 0x3C, 0xA6, 255), ivec4(0, 0, 0, 1),
ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1), InvalidationLevel::InvalidOutput,
PropertySemantics::Color)
, pyCommentsColor_("pyCommentsColor", "Comments", ivec4(0x00, 0x66, 0x00, 255),
ivec4(0, 0, 0, 1), ivec4(255, 255, 255, 1), ivec4(1, 1, 1, 1),
InvalidationLevel::InvalidOutput, PropertySemantics::Color)
, allocTest_(nullptr) {
applicationUsageModeProperty_.addOption("applicationMode", "Application Mode", 0);
applicationUsageModeProperty_.addOption("developerMode", "Developer Mode", 1);
applicationUsageModeProperty_.setSelectedIndex(1);
applicationUsageModeProperty_.setCurrentStateAsDefault();
addProperty(applicationUsageModeProperty_);
addProperty(poolSize_);
addProperty(txtEditorProperty_);
addProperty(enablePortInformationProperty_);
addProperty(enablePortInspectorsProperty_);
addProperty(portInspectorSize_);
addProperty(enablePickingProperty_);
addProperty(enableSoundProperty_);
addProperty(useRAMPercentProperty_);
addProperty(logStackTraceProperty_);
addProperty(pythonSyntax_);
addProperty(glslSyntax_);
glslSyntax_.addProperty(glslBackgroundColor_);
glslSyntax_.addProperty(glslTextColor_);
glslSyntax_.addProperty(glslCommentColor_);
glslSyntax_.addProperty(glslTypeColor_);
glslSyntax_.addProperty(glslQualifierColor_);
glslSyntax_.addProperty(glslBuiltinsColor_);
glslSyntax_.addProperty(glslGlslBuiltinsColor_);
glslSyntax_.addProperty(glslPreProcessorColor_);
pythonSyntax_.addProperty(pyFontSize_);
pythonSyntax_.addProperty(pyBGColor_);
pythonSyntax_.addProperty(pyTextColor_);
pythonSyntax_.addProperty(pyCommentsColor_);
pythonSyntax_.addProperty(pyTypeColor_);
logStackTraceProperty_.onChange(this, &SystemSettings::logStacktraceCallback);
// btnAllocTestProperty_.onChange(this, &SystemSettings::allocationTest);
// addProperty(&btnAllocTestProperty_);
pythonSyntax_.setVisible(false);
glslSyntax_.setVisible(false);
auto cores = std::thread::hardware_concurrency();
if (cores > 0) {
isDeserializing_ = true;
poolSize_.setMaxValue(cores);
poolSize_.set(static_cast<int>(0.5 * cores));
poolSize_.setCurrentStateAsDefault();
isDeserializing_ = false;
}
}
ivec4 operator*(GLint f) const
{
return ivec4(x()*f, y()*f, z()*f, w()*f);
}
void ImageLayoutGL::updateViewports(ivec2 dim, bool force) {
if (!force && (currentDim_ == dim) && (currentLayout_ == layout_.get())) return; // no changes
viewManager_.clear();
int smallWindowDim = dim.y / 3;
switch (layout_.getSelectedValue()) {
case Layout::HorizontalSplit:
// #########
// # 1 #
// #-------#
// # 2 #
// #########
// X, Y, W, H
viewManager_.push_back(
ivec4(0, horizontalSplitter_ * dim.y, dim.x, (1.f - horizontalSplitter_) * dim.y));
viewManager_.push_back(ivec4(0, 0, dim.x, horizontalSplitter_ * dim.y));
break;
case Layout::VerticalSplit:
// #########
// # | #
// # 1 | 2 #
// # | #
// #########
// X, Y, W, H
viewManager_.push_back(ivec4(0, 0, verticalSplitter_ * dim.x, dim.y));
viewManager_.push_back(
ivec4(verticalSplitter_ * dim.x, 0, (1.0f - verticalSplitter_) * dim.x, dim.y));
break;
case Layout::CrossSplit:
// #########
// # 1 | 2 #
// #-------#
// # 3 | 4 #
// #########
// X, Y, W, H
viewManager_.push_back(ivec4(0, horizontalSplitter_ * dim.y, verticalSplitter_ * dim.x,
(1.0f - horizontalSplitter_) * dim.y));
viewManager_.push_back(ivec4(verticalSplitter_ * dim.x, horizontalSplitter_ * dim.y,
(1.0f - verticalSplitter_) * dim.x,
(1.0f - horizontalSplitter_) * dim.y));
viewManager_.push_back(
ivec4(0, 0, verticalSplitter_ * dim.x, horizontalSplitter_ * dim.y));
viewManager_.push_back(ivec4(verticalSplitter_ * dim.x, 0,
(1.0f - verticalSplitter_) * dim.x,
horizontalSplitter_ * dim.y));
break;
case Layout::ThreeLeftOneRight:
// #############
// # 1 | #
// #---| #
// # 2 | 4 #
// #---| #
// # 3 | #
// #############
// X, Y, W, H
viewManager_.push_back(
ivec4(0, 2 * smallWindowDim, vertical3Left1RightSplitter_ * dim.x, smallWindowDim));
viewManager_.push_back(
ivec4(0, smallWindowDim, vertical3Left1RightSplitter_ * dim.x, smallWindowDim));
viewManager_.push_back(
ivec4(0, 0, vertical3Left1RightSplitter_ * dim.x, smallWindowDim));
viewManager_.push_back(ivec4(vertical3Left1RightSplitter_ * dim.x, 0,
(1.f - vertical3Left1RightSplitter_) * dim.x, dim.y));
break;
case Layout::ThreeRightOneLeft:
// #############
// # | 1 #
// # |---#
// # 4 | 2 #
// # |---#
// # | 3 #
// #############
// X, Y, W, H
viewManager_.push_back(ivec4(vertical3Right1LeftSplitter_ * dim.x, 2 * smallWindowDim,
(1.f - vertical3Right1LeftSplitter_) * dim.x,
smallWindowDim));
viewManager_.push_back(ivec4(vertical3Right1LeftSplitter_ * dim.x, smallWindowDim,
(1.f - vertical3Right1LeftSplitter_) * dim.x,
smallWindowDim));
viewManager_.push_back(ivec4(vertical3Right1LeftSplitter_ * dim.x, 0,
(1.f - vertical3Right1LeftSplitter_) * dim.x,
smallWindowDim));
viewManager_.push_back(ivec4(0, 0, vertical3Right1LeftSplitter_ * dim.x, dim.y));
break;
case Layout::Single:
default:
viewManager_.push_back(ivec4(0, 0, dim.x, dim.y));
}
currentDim_ = dim;
currentLayout_ = layout_.get();
}
ivec4
WRATHShapeGPUDistanceFieldCreator::ScratchPadFBO::
viewport_parameters(void)
{
return ivec4(0, 0, m_current_dim.x(), m_current_dim.y());
}
void TestWindow::resizeWindow(const QSize& size) {
_size = size;
_renderArgs->_viewport = ivec4(0, 0, _size.width(), _size.height());
}
// Variables static const char var_dest[] = "ivec4 dest;\n"; static const char var_pattern[] = "ivec4 pattern;\n"; static const char var_pixel[] = "ivec4 pixel;\n"; static const char var_src[] = "ivec4 src;\n"; static const char var_patternst[] = "vec2 patternst;\n"; // Operations static const char op_src[] = "src = ivec4(texture2D(srctex,gl_TexCoord[0].st)*vec4(colorsizesrc)+.5);\n"; static const char op_pixel[] = "pixel = ivec4(texture2D(srctex,gl_TexCoord[0].st)*vec4(colorsizedest)+.5);\n"; static const char op_color[] = "pixel = fillcolor;\n"; static const char op_dest[] = "dest = ivec4(texture2D(desttex,gl_TexCoord[1].st)*vec4(colorsizedest)+.5);\n"; static const char op_pattern[] = "patternst = vec2(mod(gl_FragCoord.x,float(patternsize.x))/float(patternsize.x),\n\ mod(gl_FragCoord.y, float(patternsize.y)) / float(patternsize.y));\n\ pattern = ivec4(texture2D(patterntex,patternst)*vec4(colorsizedest)+.5);\n"; static const char op_destout[] = "gl_FragColor = vec4(pixel)/vec4(colorsizedest);\n"; static const char op_vertex[] = "vec4 xyzw = vec4(xy[0],xy[1],0,1);\n\ mat4 proj = mat4(\n\ vec4(2.0 / (view[1] - view[0]), 0, 0, 0),\n\ vec4(0, 2.0 / (view[2] - view[3]), 0, 0),\n\ vec4(0, 0, -2.0, 0),\n\ vec4(-(view[1] + view[0]) / (view[1] - view[0]),\n\ -(view[2] + view[3]) / (view[2] - view[3]), -1 , 1));\n\ gl_Position = proj * xyzw;\n"; static const char op_vertcolorrgb[] = "gl_FrontColor = vec4(rgb,1.0);\n"; static const char op_texcoord0[] = "gl_TexCoord[0] = vec4(srcst,0.0,1.0);\n"; static const char op_texcoord1[] = "gl_TexCoord[1] = vec4(destst,0.0,1.0);\n"; static const char op_texcoord3[] = "gl_TexCoord[3] = vec4(stencilst,0.0,1.0);\n"; static const char op_ckeysrc[] = "if(src.rgb == ckeysrc) discard;\n"; static const char op_ckeydest[] = "if(dest.rgb != ckeydest) discard;\n";
ivec4 operator+(GLint f) const
{
return ivec4(x()+f, y()+f, z()+f, w()+f);
}
// ----------------------------------------------- texture_atlas_get_region ---
ivec4
texture_atlas_get_region( texture_atlas_t * self,
const size_t width,
const size_t height )
{
int y, best_height, best_width, best_index;
ivec3 *node, *prev;
ivec4 region = ivec4(0,0,width,height);
size_t i;
assert( self );
best_height = INT_MAX;
best_index = -1;
best_width = INT_MAX;
for( i=0; i<self->nodes->size; ++i )
{
y = texture_atlas_fit( self, i, width, height );
if( y >= 0 )
{
node = (ivec3 *) vector_get( self->nodes, i );
if( ( (y + height) < best_height ) ||
( ((y + height) == best_height) && (node->z < best_width)) )
{
best_height = y + height;
best_index = i;
best_width = node->z;
region.x = node->x;
region.y = y;
}
}
}
if( best_index == -1 )
{
region.x = -1;
region.y = -1;
region.z = 0;
region.w = 0;
return region;
}
node = (ivec3 *) malloc( sizeof(ivec3) );
if( node == NULL)
{
fprintf( stderr,
"line %d: No more memory for allocating data\n", __LINE__ );
exit( EXIT_FAILURE );
}
node->x = region.x;
node->y = region.y + height;
node->z = width;
vector_insert( self->nodes, best_index, node );
free( node );
for(i = best_index+1; i < self->nodes->size; ++i)
{
node = (ivec3 *) vector_get( self->nodes, i );
prev = (ivec3 *) vector_get( self->nodes, i-1 );
if (node->x < (prev->x + prev->z) )
{
int shrink = prev->x + prev->z - node->x;
node->x += shrink;
node->z -= shrink;
if (node->z <= 0)
{
vector_erase( self->nodes, i );
--i;
}
else
{
break;
}
}
else
{
break;
}
}
texture_atlas_merge( self );
self->used += width * height;
return region;
}
ivec4 operator/(const ivec4& v) const
{
return ivec4(x()/v.x(), y()/v.y(), z()/v.z(), w()/v.w());
}
