//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void OverlayItems::onMousePressEvent(MouseButton buttonPressed, MouseEvent* mouseEvent)
{
if (buttonPressed == LeftButton && mouseEvent->modifiers() == ControlModifier)
{
Rendering* mainRendering = m_renderSequence->rendering(0);
int winCoordX = mouseEvent->x();
int winCoordY = mouseEvent->y();
Trace::show("\nPicking overlay item at (%d,%d)...", winCoordX, winCoordY);
OverlayItem* item = mainRendering->overlayItemFromWindowCoordinates(winCoordX, winCoordY);
if (item)
{
if (dynamic_cast<OverlayTextBox*>(item))
{
OverlayTextBox* textItem = dynamic_cast<OverlayTextBox*>(item);
Trace::show("Hit text box with text:\n%s", textItem->text().toAscii().ptr());
}
else
{
Trace::show("Hit some overlay item");
}
}
else
{
Trace::show("NO hits");
}
return;
}
TestSnippet::onMousePressEvent(buttonPressed, mouseEvent);
}
BSP::~BSP()
{
while( _renderings.size() )
{
Rendering* rendering = *_renderings.begin();
remove( rendering );
rendering->release();
}
while( _particleSystems.size() )
{
ParticleSystem* pSys = *_particleSystems.begin();
remove( pSys );
pSys->release();
}
while( _clumps.size() )
{
Clump* clump = *_clumps.begin();
remove( clump );
clump->release();
}
while( _lights.size() )
{
Light* light = *_lights.begin();
remove( light );
light->release();
}
delete _root;
for( int i=0; i<_numShaders; i++ ) _shaders[i]->release();
delete _shaders;
delete _shadowVolume;
}
virtual void resizeEvent(int w, int h)
{
if ( mRenderingTree->subRenderings()->size() < 4 )
return;
int hw = w/2;
int hh = h/2;
mRenderingTree->subRenderings()->at(2)->as<Rendering>()->renderer()->framebuffer()->setWidth(w);
mRenderingTree->subRenderings()->at(2)->as<Rendering>()->renderer()->framebuffer()->setHeight(h);
mRenderingTree->subRenderings()->at(2)->as<Rendering>()->camera()->viewport()->set(0,0,hw,hh);
mRenderingTree->subRenderings()->at(2)->as<Rendering>()->camera()->setProjectionPerspective();
mRenderingTree->subRenderings()->at(1)->as<Rendering>()->renderer()->framebuffer()->setWidth(w);
mRenderingTree->subRenderings()->at(1)->as<Rendering>()->renderer()->framebuffer()->setHeight(h);
mRenderingTree->subRenderings()->at(1)->as<Rendering>()->camera()->viewport()->set(hw,hh,w-hw,h-hh);
mRenderingTree->subRenderings()->at(1)->as<Rendering>()->camera()->setProjectionPerspective();
mRenderingTree->subRenderings()->at(0)->as<Rendering>()->renderer()->framebuffer()->setWidth(w);
mRenderingTree->subRenderings()->at(0)->as<Rendering>()->renderer()->framebuffer()->setHeight(h);
mRenderingTree->subRenderings()->at(0)->as<Rendering>()->camera()->viewport()->set(0,hh,hw,h-hh);
mRenderingTree->subRenderings()->at(0)->as<Rendering>()->camera()->setProjectionPerspective();
mRenderingTree->subRenderings()->at(3)->as<Rendering>()->renderer()->framebuffer()->setWidth(w);
mRenderingTree->subRenderings()->at(3)->as<Rendering>()->renderer()->framebuffer()->setHeight(h);
mRenderingTree->subRenderings()->at(3)->as<Rendering>()->camera()->viewport()->set(hw,0,w-hw,hh);
mRenderingTree->subRenderings()->at(3)->as<Rendering>()->camera()->setProjectionPerspective();
Rendering* rend = mRenderingTree->subRenderings()->at(0)->as<Rendering>();
bindManipulators( rend->camera() );
}
//-----------------------------------------------------------------------------
void Applet::resizeEvent(int w, int h)
{
// if a simple Rendering is attached as the rendering root than update viewport and projection matrix.
Rendering* rend = cast<Rendering>(rendering());
if (rend)
{
VL_CHECK( w == rend->renderer()->framebuffer()->width() );
VL_CHECK( h == rend->renderer()->framebuffer()->height() );
rend->camera()->viewport()->setWidth( w );
rend->camera()->viewport()->setHeight( h );
rend->camera()->setProjectionPerspective();
}
}
void mouseDownEvent(EMouseButton, int x, int y)
{
for( int i=0; i<mRenderingTree->subRenderings()->size(); ++i )
{
int height = mRenderingTree->subRenderings()->at(i)->as<Rendering>()->renderer()->framebuffer()->height();
if ( mRenderingTree->subRenderings()->at(i)->as<Rendering>()->camera()->viewport()->isPointInside(x,y,height) )
{
Rendering* rend = mRenderingTree->subRenderings()->at(i)->as<Rendering>();
bindManipulators( rend->camera() );
trackball()->setTransform( _tr2.get() );
break;
}
}
}
void VLBaseView::fitWorld()
{
Rendering* rend = cast<Rendering>(rendering());
if (rend)
{
sceneManager()->setBoundsDirty(true);
sceneManager()->computeBounds();
const vl::Sphere bs = sceneManager()->boundingSphere();
vl::vec3 new_at = bs.center();
mTrackball->setPivot(new_at);
//Set projection matrix
float w = (float) rend->camera()->viewport()->width();
float h = (float) rend->camera()->viewport()->height();
if (bs.radius()>0)
{
float aspectRatio = rend->camera()->aspectRatio();
if (aspectRatio>1)
{
h = bs.radius()*2.0f*1.01f;
w = h*aspectRatio;
}
else
{
if(aspectRatio != 0)
{
w = bs.radius()*2.0f*1.01f;
h = w/aspectRatio;
}
}
}
OrthographicTrackballManipulator* pOrthoTM = dynamic_cast<OrthographicTrackballManipulator*>(trackball());
if (pOrthoTM)
{
float zoomFactor = 1.0f*rend->camera()->viewport()->width()/w;
pOrthoTM->SetZoomFactor(zoomFactor);
}
const float nearPlane = 0.05f;
const float farPlane = 2.5f*w;
// install the orthographic projection
if (rend->camera()->projectionMatrixType() == PMT_OrthographicProjection )
{
rend->camera()->setProjectionOrtho(-w/2.0f,w/2.0f,-h/2.0f,h/2.0f, nearPlane, farPlane);
}
else
{
// TODO: 7/19/2012 mwu Doesn't work
rend->camera()->setProjectionMatrix(
// // compute directly an orthographic projection & center the scene on the screen
// rend->camera()->projectionMatrix() *
// vl::mat4::getTranslation(w / 2.0f, h / 2.0f, 0),PMT_PerspectiveProjection);
vl::mat4::getOrtho(0, w, 0, h, nearPlane, farPlane)
/** vl::mat4::getTranslation(w / 2.0f, h / 2.0f, 0)*/
,PMT_PerspectiveProjection) ;
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void QSRSnippetWidget::setPixelSizeCullingThreshold(double threshold)
{
RenderSequence* renderSeq = m_snippet->renderSequence();
CVF_ASSERT(renderSeq);
int numPasses = renderSeq->renderingCount();
int i;
for (i = 0; i < numPasses; i++)
{
Rendering* rendering = renderSeq->rendering(i);
CVF_ASSERT(rendering);
rendering->cullSettings()->setPixelSizeCullingAreaThreshold(threshold);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void QSRSnippetWidget::enablePixelSizeCulling(bool enable)
{
RenderSequence* renderSeq = m_snippet->renderSequence();
CVF_ASSERT(renderSeq);
int numPasses = renderSeq->renderingCount();
int i;
for (i = 0; i < numPasses; i++)
{
Rendering* rendering = renderSeq->rendering(i);
CVF_ASSERT(rendering);
rendering->cullSettings()->enablePixelSizeCulling(enable);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void QSRSnippetWidget::enableForcedImmediateMode(bool enable)
{
RenderSequence* renderSeq = m_snippet->renderSequence();
CVF_ASSERT(renderSeq);
int numRenderings = renderSeq->renderingCount();
int i;
for (i = 0; i < numRenderings; i++)
{
Rendering* rendering = renderSeq->rendering(i);
CVF_ASSERT(rendering);
cvf::RenderEngine* engine = rendering->renderEngine();
CVF_ASSERT(engine);
engine->enableForcedImmediateMode(enable);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void QSRSnippetWidget::enableItemCountUpdates(bool enable)
{
RenderSequence* renderSeq = m_snippet->renderSequence();
CVF_ASSERT(renderSeq);
int numPasses = renderSeq->renderingCount();
int i;
for (i = 0; i < numPasses; i++)
{
Rendering* rendering = renderSeq->rendering(i);
CVF_ASSERT(rendering);
cvf::RenderEngine* engine = rendering->renderEngine();
CVF_ASSERT(engine);
engine->enableItemCountUpdate(enable);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void QSRSnippetWidget::setApplyEffectsDisabled(bool disable)
{
RenderSequence* renderSeq = m_snippet->renderSequence();
CVF_ASSERT(renderSeq);
int numPasses = renderSeq->renderingCount();
int i;
for (i = 0; i < numPasses; i++)
{
Rendering* rendering = renderSeq->rendering(i);
CVF_ASSERT(rendering);
cvf::RenderEngine* engine = rendering->renderEngine();
CVF_ASSERT(engine);
engine->disableApplyEffects(disable);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void QSRSnippetWidget::showModelStatistics()
{
RenderSequence* renderSeq = m_snippet->renderSequence();
CVF_ASSERT(renderSeq);
size_t totPartCount = 0;
size_t totFaceCount = 0;
int numRenderings = renderSeq->renderingCount();
int ir;
for (ir = 0; ir < numRenderings; ir++)
{
Rendering* rendering = renderSeq->rendering(ir);
CVF_ASSERT(rendering);
Scene* scene = rendering->scene();
CVF_ASSERT(scene);
int numModels = scene->modelCount();
int im;
for (im = 0; im < numModels; im++)
{
Model* model = scene->model(im);
Collection<Part> allParts;
model->allParts(&allParts);
size_t numParts = allParts.size();
size_t ip;
for (ip = 0; ip < numParts; ip++)
{
Part* part = allParts[ip].p();
Drawable* drawable = part->drawable();
totPartCount++;
totFaceCount += drawable->faceCount();
}
}
}
cvf::Trace::show("Total number of parts: %ld", totPartCount);
cvf::Trace::show("Total number of faces: %ld", totFaceCount);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void QSRSnippetWidget::setRenderMode(DrawableGeo::RenderMode mode)
{
m_lastSetRenderMode = mode;
Collection<Part> allParts;
RenderSequence* renderSeq = m_snippet->renderSequence();
CVF_ASSERT(renderSeq);
int numPasses = renderSeq->renderingCount();
int i;
for (i = 0; i < numPasses; i++)
{
Rendering* rendering = renderSeq->rendering(i);
CVF_ASSERT(rendering);
Scene* scene = rendering->scene();
CVF_ASSERT(scene);
scene->allParts(&allParts);
}
size_t numParts = allParts.size();
size_t partIdx;
for (partIdx = 0; partIdx < numParts; partIdx++)
{
Part* part = allParts.at(partIdx);
cvf::uint lod;
for (lod = 0; lod < cvf::Part::MAX_NUM_LOD_LEVELS; lod++)
{
DrawableGeo* drawableGeo = dynamic_cast<DrawableGeo*>(part->drawable(lod));
if (drawableGeo)
{
drawableGeo->setRenderMode(m_lastSetRenderMode);
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void QSRSnippetWidget::convertDrawablesToShort()
{
RenderSequence* renderSeq = m_snippet->renderSequence();
CVF_ASSERT(renderSeq);
int numPasses = renderSeq->renderingCount();
int i;
for (i = 0; i < numPasses; i++)
{
Rendering* rendering = renderSeq->rendering(i);
CVF_ASSERT(rendering);
Scene* scene = rendering->scene();
CVF_ASSERT(scene);
int numModels = scene->modelCount();
int j;
for (j = 0; j < numModels; j++)
{
Model* model = scene->model(j);
Collection<Part> partCollection;
model->allParts(&partCollection);
size_t numParts = partCollection.size();
size_t i;
for (i = 0; i < numParts; i++)
{
DrawableGeo* drawable = dynamic_cast<DrawableGeo*>(partCollection.at(i)->drawable());
if (drawable)
{
drawable->convertFromUIntToUShort();
}
}
}
}
}
// the entry point for any Windows program
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
// the handle for the window, filled by a function
HWND hWnd;
// this struct holds information for the window class
WNDCLASSEX wc;
// clear out the window class for use
ZeroMemory(&wc, sizeof(WNDCLASSEX));
// fill in the struct with the needed information
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WindowProc;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
//wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
wc.lpszClassName = L"WindowClass1";
// register the window class
RegisterClassEx(&wc);
// calculate the size of the client area
RECT wr = { 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT }; // set the size, but not the position
AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE); // adjust the size
// create the window and use the result as the handle
hWnd = CreateWindowEx(NULL,
L"WindowClass1", // name of the window class
L"Our First Windowed Program", // title of the window
WS_OVERLAPPEDWINDOW, // window style
0, // x-position of the window
0, // y-position of the window
wr.right - wr.left,
wr.bottom - wr.top,
NULL, // we have no parent window, NULL
NULL, // we aren't using menus, NULL
hInstance, // application handle
NULL); // used with multiple windows, NULL
// display the window on the screen
ShowWindow(hWnd, nCmdShow);
// set up and initialize Direct3D
rendering.InitD3D(hWnd);
rendering.InitPipeline();
rendering.InitGraphics((void*)kinect_manager.m_pColorRGBX);
HRESULT hr = kinect_manager.Initialize();
if (FAILED(hr)) {
return E_FAIL;
}
// enter the main loop:
// this struct holds Windows event messages
MSG msg = { 0 };
// Enter the infinite message loop
while (TRUE)
{
// Check to see if any messages are waiting in the queue
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
// translate keystroke messages into the right format
TranslateMessage(&msg);
// send the message to the WindowProc function
DispatchMessage(&msg);
// check to see if it's time to quit
if (msg.message == WM_QUIT)
break;
}
else
{
// Run game code here
// ...
// ...
kinect_manager.Update();
rendering.UpdateTextureBuffer((void*)(kinect_manager.m_pColorRGBX), kinect_manager.color_frame_length_in_pixels,kinect_manager.color_frame_bytes_per_pixel);
rendering.Render();
}
}
kinect_manager.Cleanup();
// clean up DirectX and COM
rendering.CleanD3D();
// return this part of the WM_QUIT message to Windows
return msg.wParam;
}
void AbstractOnGpuComparator::filter(Rendering::RenderingContext & context, TexRef_t src, TexRef_t dst) {
if (!filterValid) {
shaderFilterH->setUniform(context, Uniform("filterSize", filterSize));
shaderFilterV->setUniform(context, Uniform("filterSize", filterSize));
// std::cerr << getTypeName() << " Filter: " << (filterType == GAUSS ? "Gauss" : "Box") << " (" << filterSize << ") : " << "[";
std::vector<float> values;
if (filterType == GAUSS) {
// old formula was filterSize * 1.5, which was too big.
// older value used for some measurements in 2013's papers: 0.3
const double sigma = 0.3 * (filterSize - 1) + 0.8;
// sqrtOfTwoTimesPi = std::sqrt(2.0 * pi)
const double sqrtOfTwoTimesPi = 2.506628274631000502415765284811045253006986740609938316629923;
const double a = 1.0 / (sigma * sqrtOfTwoTimesPi);
double sum = 0.0;
for (int i = 0; i <= filterSize; i++) {
const double v = a * std::exp(-((i * i) / (2.0 * sigma * sigma)));
values.push_back(v);
sum += (i == 0 ? v : 2 * v);
}
for (int i = 0; i <= filterSize; i++) {
values[i] /= sum;
}
}
else if (filterType == BOX) {
for (int i = 0; i <= filterSize; i++) {
float v = 1.0f / (filterSize * 2.0f + 1.0f);
values.push_back(v);
}
}
else
WARN("the roof is on fire");
// for(const auto & x : values)
// std::cerr << x << " ";
// std::cerr << "\b]" << std::endl;
while (values.size() < 16)
values.push_back(0.0f);
shaderFilterH->setUniform(context, Uniform("filterValues", values));
shaderFilterV->setUniform(context, Uniform("filterValues", values));
filterValid = true;
}
Reference<TexRef> tmp = new TexRef(Vec2i(src->get()->getWidth(), src->get()->getHeight()));
context.pushAndSetShader(shaderFilterH.get());
context.pushAndSetTexture(0, src->get());
fbo->attachColorTexture(context, tmp->get());
Rendering::drawFullScreenRect(context);
context.setShader(shaderFilterV.get());
context.setTexture(0, tmp->get());
fbo->attachColorTexture(context, dst.isNull() ? src->get() : dst->get());
Rendering::drawFullScreenRect(context);
fbo->detachColorTexture(context);
context.popTexture(0);
context.popShader();
}
void VLBaseView::setViewMode( ViewMode eViewMode,bool bFitWorld /*= true*/ )
{
mViewMode = eViewMode;
if (eViewMode == ViewNone)
return;
if (bFitWorld)
{
fitWorld();
}
Rendering* rend = cast<Rendering>(rendering());
if (rend)
{
sceneManager()->setBoundsDirty(true);
sceneManager()->computeBounds();
const vl::Sphere bs = sceneManager()->boundingSphere();
/* define the camera position and orientation */
vl::vec3 eye;
vl::vec3 at;
vl::vec3 up;
at = bs.center();
float length = 2.5f*bs.radius();//when it is small, some problems with hidden line and silhouette calculation
switch(mViewMode)
{
case ViewXY:
eye = at;
eye.z() = at.z() + length;
up = vec3(0,1,0);
rend->camera()->setViewMatrixLookAt(eye, at,up);
break;
case ViewYX:
eye = at;
eye.z() = at.z() - length;
up = vec3(0,1,0);
rend->camera()->setViewMatrixLookAt(eye, at,up);
break;
case ViewXZ:
eye = at;
eye.y() = at.y() - length;
up = vec3(0,0,1);
rend->camera()->setViewMatrixLookAt(eye, at,up);
break;
case ViewZX:
eye = at;
eye.y() = at.y() + length;
up = vec3(0,0,1);
rend->camera()->setViewMatrixLookAt(eye, at,up);
break;
case ViewYZ:
eye = at;
eye.x() = at.x() + length;
up = vec3(0,0,1);
rend->camera()->setViewMatrixLookAt(eye, at,up);
break;
case ViewZY:
eye = at;
eye.x() = at.x() - length;
up = vec3(0,0,1);
rend->camera()->setViewMatrixLookAt(eye, at,up);
break;
case ViewIso:
{
vec3 frontAxis(1,0,0);
vec3 topAxis(0,0,1);
vec3 rightAxis = -cross(frontAxis,topAxis);
// float newLen = length * 0.5774f;
float newLen = length * 1.0f;
eye.x() = at.x()+newLen*frontAxis.x()+newLen*rightAxis.x()+newLen*topAxis.x();
eye.y() = at.y()+newLen*frontAxis.y()+newLen*rightAxis.y()+newLen*topAxis.y();
eye.z() = at.z()+newLen*frontAxis.z()+newLen*rightAxis.z()+newLen*topAxis.z();
up = topAxis;
rend->camera()->setViewMatrixLookAt(eye, at,up);
}
break;
default: break;
}
}
openglContext()->update();
}
