void CanvasContext::draw() {
LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE,
"drawRenderNode called on a context with no canvas or surface!");
SkRect dirty;
mDamageAccumulator.finish(&dirty);
// TODO: Re-enable after figuring out cause of b/22592975
// if (dirty.isEmpty() && Properties::skipEmptyFrames) {
// mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
// return;
// }
mCurrentFrameInfo->markIssueDrawCommandsStart();
EGLint width, height;
mEglManager.beginFrame(mEglSurface, &width, &height);
if (width != mCanvas->getViewportWidth() || height != mCanvas->getViewportHeight()) {
mCanvas->setViewport(width, height);
dirty.setEmpty();
} else if (!mBufferPreserved || mHaveNewSurface) {
dirty.setEmpty();
} else {
if (!dirty.isEmpty() && !dirty.intersect(0, 0, width, height)) {
ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?",
SK_RECT_ARGS(dirty), width, height);
dirty.setEmpty();
}
profiler().unionDirty(&dirty);
}
if (!dirty.isEmpty()) {
mCanvas->prepareDirty(dirty.fLeft, dirty.fTop,
dirty.fRight, dirty.fBottom, mOpaque);
} else {
mCanvas->prepare(mOpaque);
}
Rect outBounds;
mCanvas->drawRenderNode(mRootRenderNode.get(), outBounds);
profiler().draw(mCanvas);
bool drew = mCanvas->finish();
// Even if we decided to cancel the frame, from the perspective of jank
// metrics the frame was swapped at this point
mCurrentFrameInfo->markSwapBuffers();
if (drew) {
swapBuffers(dirty, width, height);
}
// TODO: Use a fence for real completion?
mCurrentFrameInfo->markFrameCompleted();
mJankTracker.addFrame(*mCurrentFrameInfo);
mRenderThread.jankTracker().addFrame(*mCurrentFrameInfo);
}
int main( int argc, char * argv[] ) {
std::size_t n;
std::size_t r;
bool d;
std::string filename;
try {
TCLAP::CmdLine cmd( "Output VCP vectors for pairs read from standard input.", ' ', "1.0.0" );
std::vector<std::size_t> allowedN {3, 4, 5, 6, 7, 8};
TCLAP::ValuesConstraint<std::size_t> allowedNVals( allowedN );
TCLAP::UnlabeledValueArg<std::size_t> nArg( "n", "n\tNumber of vertices in the VCP", true, 3, &allowedNVals, cmd );
TCLAP::UnlabeledValueArg<std::size_t> rArg( "r", "r\tNumber of relations in the VCP", true, 1, "[1,inf]", cmd );
std::vector<std::size_t> allowedD {0, 1};
TCLAP::ValuesConstraint<std::size_t> allowedDVals( allowedD );
TCLAP::UnlabeledValueArg<std::size_t> dArg( "d", "d\tWhether the VCP considers directedness", true, 0, &allowedDVals, cmd );
TCLAP::UnlabeledValueArg<std::string> filenameArg( "graph_filename", "\tThe name of the file containing the graph", true, "", "graph_filename", cmd );
cmd.parse( argc, argv );
n = nArg.getValue();
r = rArg.getValue();
d = dArg.getValue();
filename = filenameArg.getValue();
} catch( TCLAP::ArgException & e ) {
std::cerr << "error: " << e.error() << " for arg " << e.argId() << std::endl;
return 1;
}
std::ifstream file;
file.open( filename, std::ifstream::in );
if( !file ) {
std::cerr << "error opening file: " << filename << std::endl;
}
vcp::vertex_id_t v1;
vcp::vertex_id_t v2;
if( d ) {
if( n == 3 ) {
if( r == 1 ) {
vcp::directed_graph g;
file >> g;
vcp::vcp<3,1,1> profiler( g );
while( std::cin >> v1 >> v2 ) {
std::cout << profiler.generate_vector( vcp::const_vertex_iterator( g.vertices_begin() + v1 ), vcp::const_vertex_iterator( g.vertices_begin() + v2) );
}
} else if( r == 2 ) {
vcp::multirelational_directed_graph<2> g;
file >> g;
vcp::vcp<3,2,1> profiler( g );
while( std::cin >> v1 >> v2 ) {
std::cout << profiler.generate_vector( vcp::const_vertex_iterator( g.vertices_begin() + v1 ), vcp::const_vertex_iterator( g.vertices_begin() + v2) );
}
} else if( r == 30 ) {
void CanvasContext::draw() {
LOG_ALWAYS_FATAL_IF(!mCanvas || mEglSurface == EGL_NO_SURFACE,
"drawRenderNode called on a context with no canvas or surface!");
profiler().markPlaybackStart();
SkRect dirty;
mDamageAccumulator.finish(&dirty);
EGLint width, height;
mEglManager.beginFrame(mEglSurface, &width, &height);
if (width != mCanvas->getViewportWidth() || height != mCanvas->getViewportHeight()) {
mCanvas->setViewport(width, height);
dirty.setEmpty();
} else if (!mBufferPreserved || mHaveNewSurface) {
dirty.setEmpty();
} else {
if (!dirty.isEmpty() && !dirty.intersect(0, 0, width, height)) {
//ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?",
// SK_RECT_ARGS(dirty), width, height);
dirty.setEmpty();
}
profiler().unionDirty(&dirty);
}
status_t status;
if (!dirty.isEmpty()) {
status = mCanvas->prepareDirty(dirty.fLeft, dirty.fTop,
dirty.fRight, dirty.fBottom, mOpaque);
} else {
status = mCanvas->prepare(mOpaque);
}
Rect outBounds;
status |= mCanvas->drawRenderNode(mRootRenderNode.get(), outBounds);
profiler().draw(mCanvas);
mCanvas->finish();
profiler().markPlaybackEnd();
if (status & DrawGlInfo::kStatusDrew) {
swapBuffers();
} else {
mEglManager.cancelFrame();
}
profiler().finishFrame();
}
void GUIRenderer::display(float dt)
{
ScopeProfiler profiler("3d", "uiRenderDisplay");
ShaderManager::instance()->bind(GUIShader);
glUniform1i(diffuseTexSamplerLoc, 0);
glActiveTexture(GL_TEXTURE0);
for (auto &widget : widgets)
{
if(widget->isVisible())
{
Vector2<int> translateVector(widget->getGlobalPositionX(), widget->getGlobalPositionY());
glUniform2iv(translateDistanceLoc, 1, (const int*)translateVector);
widget->display(translateDistanceLoc, dt);
}
}
#ifdef _DEBUG
// //display font texture
// Font *font = MediaManager::instance()->getMedia<Font>("font/font.fnt");
//
// TextureDisplayer textureDisplayer(font->getTextureID(), TextureDisplayer::DEFAULT_VALUE);
// textureDisplayer.setPosition(TextureDisplayer::USER_DEFINED_X, TextureDisplayer::USER_DEFINED_Y);
// textureDisplayer.setSize(20.0, font->getDimensionTexture() + 20.0, 20.0, font->getDimensionTexture() + 20.0);
// textureDisplayer.initialize(512, 512, -1.0, -1.0);
// textureDisplayer.display();
// font->release();
#endif
}
void
FFTMemoryCache::initialise()
{
Profiler profiler("FFTMemoryCache::initialise");
size_t width = m_width, height = m_height;
#ifdef DEBUG_FFT_MEMORY_CACHE
std::cerr << "FFTMemoryCache[" << this << "]::initialise(" << width << "x" << height << " = " << width*height << ")" << std::endl;
#endif
if (m_storageType == FFTCache::Compact) {
initialise(m_magnitude);
initialise(m_phase);
} else if (m_storageType == FFTCache::Polar) {
initialise(m_fmagnitude);
initialise(m_fphase);
} else {
initialise(m_freal);
initialise(m_fimag);
}
m_colset.resize(width);
m_factor = (float *)realloc(m_factor, width * sizeof(float));
m_width = width;
m_height = height;
#ifdef DEBUG_FFT_MEMORY_CACHE
std::cerr << "done, width = " << m_width << " height = " << m_height << std::endl;
#endif
}
void AmbientOcclusionManager::updateAOTexture(const Camera *camera)
{
ScopeProfiler profiler("3d", "updateAOTexture");
GLint activeFBO;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &activeFBO);
glBindFramebuffer(GL_FRAMEBUFFER, fboID);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, depthTexID);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, normalAndAmbientTexID);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, noiseTexId);
ShaderManager::instance()->bind(ambientOcclusionShader);
glUniformMatrix4fv(mInverseViewProjectionLoc, 1, GL_FALSE, (const float*) (camera->getProjectionMatrix() * camera->getViewMatrix()).inverse());
glUniformMatrix4fv(mProjectionLoc, 1, GL_FALSE, (const float*) camera->getProjectionMatrix());
glUniformMatrix4fv(mViewLoc, 1, GL_FALSE, (const float*) camera->getViewMatrix());
glViewport(0, 0, textureSizeX, textureSizeY);
quadDisplayer->display();
if(isBlurActivated)
{
verticalBlurFilter->applyOn(ambientOcclusionTexID);
horizontalBlurFilter->applyOn(verticalBlurFilter->getTextureID());
}
glViewport(0, 0, sceneWidth, sceneHeight);
glBindFramebuffer(GL_FRAMEBUFFER, static_cast<GLuint>(activeFBO));
}
bool
MatrixFile::haveSetColumnAt(size_t x) const
{
if (m_mode == WriteOnly) {
return m_setColumns->get(x);
}
if (m_readyToReadColumn >= 0 &&
size_t(m_readyToReadColumn) == x) return true;
Profiler profiler("MatrixFile::haveSetColumnAt");
#ifdef DEBUG_MATRIX_FILE_READ_SET
std::cerr << "MatrixFile[" << m_fd << "]::haveSetColumnAt(" << x << ")" << std::endl;
// std::cerr << ".";
#endif
unsigned char set = 0;
if (!seekTo(x)) {
std::cerr << "ERROR: MatrixFile::haveSetColumnAt(" << x << "): Seek failed" << std::endl;
throw FileOperationFailed(m_fileName, "seek");
}
ssize_t r = -1;
r = ::read(m_fd, &set, 1);
if (r < 0) {
::perror("MatrixFile::haveSetColumnAt: read failed");
throw FileReadFailed(m_fileName);
}
if (set) m_readyToReadColumn = int(x);
return set;
}
LRESULT CDocProfileTab::OnInitDialog(UINT , WPARAM , LPARAM , BOOL& )
{
HWND hDlgItem = GetDlgItem(IDC_PROFTEXT);
CStdString sMessageText(_T("The "));
sMessageText += _T(DOCPROV_DESCRIPTION);
sMessageText += _T(" integration allows users to add documents to an Interwoven Database either by manually filling out a document profile, or by choosing the auotprofile option below.\n\n Setting this option will allow the document to be saved using default values.");
sMessageText += _T("To choose which of these options you wish to use please click on one of the buttons below and then click Apply.");
::SetWindowText(hDlgItem, sMessageText.c_str()) ;
ATLControls::CButton rbAutoProf(GetDlgItem(IDC_AUTOPROF));
ATLControls::CButton rbUserProf(GetDlgItem(IDC_USERPROF));
ATLControls::CButton rbCustomClass(GetDlgItem(IDC_CHECK_CLASS));
InitializeSettings() ;
rbAutoProf.SetCheck(m_bAutoProfile) ;
rbUserProf.SetCheck(!m_bAutoProfile) ;
CDocumentProfiler profiler( NULL );
m_bUseCustomCollabClass = profiler.UseCustomClassName();
rbCustomClass.SetCheck( m_bUseCustomCollabClass );
::EnableWindow( GetDlgItem( IDC_EDIT_CLASS ), m_bUseCustomCollabClass );
CStdString sCustomClass = profiler.GetCustomClassName();
::SetWindowText( GetDlgItem( IDC_EDIT_CLASS ), sCustomClass.empty() ? _T("COMPARE") : sCustomClass );
if(FeatureGuard::IsWorkshareCompareInstall())
{
::SetWindowPos(GetDlgItem(IDC_EDIT_CLASS),NULL,0,0,0,0,SWP_HIDEWINDOW|SWP_NOMOVE);
::SetWindowPos(GetDlgItem(IDC_CHECK_CLASS),NULL,0,0,0,0,SWP_HIDEWINDOW|SWP_NOMOVE);
}
return 1; // Let the system set the focus
}
void
Panner::drawItems(QPainter *painter, int numItems,
QGraphicsItem *items[],
const QStyleOptionGraphicsItem options[])
{
Profiler profiler("Panner::drawItems");
if (m_cache.size() != viewport()->size()) {
QGraphicsScene *s = scene();
if (!s) return;
PannerScene *ps = static_cast<PannerScene *>(s);
m_cache = QPixmap(viewport()->size());
m_cache.fill(Qt::transparent);
QPainter cachePainter;
cachePainter.begin(&m_cache);
cachePainter.setTransform(viewportTransform());
ps->drawItems(&cachePainter, numItems, items, options);
cachePainter.end();
}
painter->save();
painter->setTransform(QTransform());
painter->drawPixmap(0, 0, m_cache);
painter->restore();
}
void history_t::add(const history_item_t &item)
{
scoped_lock locker(lock);
/* Try merging with the last item */
if (! new_items.empty() && new_items.back().merge(item)) {
/* We merged, so we don't have to add anything */
}
else
{
/* We have to add a new item */
new_items.push_back(item);
unsaved_item_count++;
}
/* Prevent the first write from always triggering a save */
time_t now = time(NULL);
if (! save_timestamp)
save_timestamp = now;
/* This might be a good candidate for moving to a background thread */
if((now > save_timestamp + SAVE_INTERVAL) || (unsaved_item_count >= SAVE_COUNT)) {
time_profiler_t profiler("save_internal");
this->save_internal();
}
}
void
Panned::paintEvent(QPaintEvent *e)
{
Profiler profiler("Panned::paintEvent");
QGraphicsView::paintEvent(e);
}
void
Panned::drawForeground(QPainter *paint, const QRectF &)
{
Profiler profiler("Panned::drawForeground");
QPointF near = mapToScene(0, 0);
QPointF far = mapToScene(width(), height());
QSizeF sz(far.x()-near.x(), far.y()-near.y());
QRectF pr(near, sz);
// RG_DEBUG << "Panned::drawForeground: pr = " << pr << endl;
if (pr != m_pannedRect) {
if (pr.x() != m_pannedRect.x()) emit pannedContentsScrolled();
m_pannedRect = pr;
emit pannedRectChanged(pr);
}
if (m_pointerVisible && scene()) {
QPoint top = mapFromScene(m_pointerTop);
float height = m_pointerHeight;
if (height == 0.f) height = scene()->height();
QPoint bottom = mapFromScene
(m_pointerTop + QPointF(0, height));
paint->save();
paint->setWorldMatrix(QMatrix());
paint->setPen(QPen(GUIPalette::getColour(GUIPalette::Pointer), 2));
paint->drawLine(top, bottom);
paint->restore();
}
}
MStatus AlembicProfileBeginCommand::doIt(const MArgList& args) {
MStatus status = MS::kSuccess;
#ifdef ESS_PROFILING
MArgParser argData(syntax(), args, &status);
if(!argData.isFlagSet("fileNameArg"))
{
// TODO: display dialog
MGlobal::displayError("[ExocortexAlembic] No fileName specified.");
return status;
}
// get the filename arg
MString fileName = argData.flagArgumentString("fileNameArg",0);
std::string strFileName( fileName.asChar() );
if( nameToProfiler.find( strFileName ) == nameToProfiler.end() ) {
boost::shared_ptr<Profiler> profiler( new Profiler( strFileName.c_str() ) );
nameToProfiler.insert( std::pair<std::string, boost::shared_ptr<Profiler>>( strFileName, profiler ) );
}
else {
nameToProfiler[ strFileName]->resume();
}
#endif
return status;
}
void
MappedBufMetaIterator::
fetchEvents(MappedInserterBase &inserter,
const RealTime& startTime,
const RealTime& endTime)
{
Profiler profiler("MappedBufMetaIterator::fetchEvents", false);
#ifdef DEBUG_META_ITERATOR
SEQUENCER_DEBUG << "MBMI::fetchEvents "
<< startTime << " -> "
<< endTime << endl;
#endif
// To keep mappers on the same channel from interfering, for
// instance sending their initializations while another is playing
// on the channel, we slice the timeslice into slices during which
// no new mappers start and pass each slice to
// fetchEventsNoncompeting. We could re-slice it smarter but this
// suffices.
// Make a queue of all segment starts that occur during the slice.
std::priority_queue<RealTime,
std::vector<RealTime>,
std::greater<RealTime> >
segStarts;
for (segmentiterators::iterator i = m_iterators.begin();
i != m_iterators.end();
++i) {
RealTime start, end;
(*i)->getSegment()->getStartEnd(start, end);
if ((start >= startTime) && (start < endTime))
{ segStarts.push(start); }
}
// The progressive starting time, updated each iteration.
RealTime innerStart = startTime;
// For each distinct gap, do a slice.
while (!segStarts.empty()) {
// We're at innerStart. Get a mapper that didn't start yet.
RealTime innerEnd = segStarts.top();
// Remove it from the queue.
segStarts.pop();
// If it starts exactly at innerStart, it doesn't need its own
// slice.
if (innerEnd == innerStart) { continue; }
// Get a slice from the previous end-time (or startTime) to
// this new start-time.
fetchEventsNoncompeting(inserter, innerStart, innerEnd);
innerStart = innerEnd;
}
// Do one more slice to take us to the end time. This is always
// correct to do, since segStarts can't contain a start equal to
// endTime.
fetchEventsNoncompeting(inserter, innerStart, endTime);
return;
}
void NuiOpenCLKernelManager::buildAllShaders()
{
NuiProfilingScope profiler("NuiOpenCLKernelManager::buildAllShaders()");
for (auto i = 0; i < E_KERNEL_COUNT; ++i){
acquireKernel((EXGenOCLKernelName)i);
}
}
std::wstring ThreadList::getLocation(HANDLE thread_handle) {
PROFILER_ADDR profaddr = 0;
try {
std::map<CallStack, SAMPLE_TYPE> callstacks;
std::map<PROFILER_ADDR, SAMPLE_TYPE> flatcounts;
Profiler profiler(process_handle, thread_handle, callstacks, flatcounts);
bool ok = profiler.sampleTarget(0, syminfo);
if (ok && !profiler.targetExited() && callstacks.size() > 0)
{
const CallStack &stack = callstacks.begin()->first;
profaddr = stack.addr[0];
// Collapse functions down
if (syminfo && stack.depth > 0)
{
for (size_t n=0;n<stack.depth;n++)
{
PROFILER_ADDR addr = stack.addr[n];
std::wstring mod = syminfo->getModuleNameForAddr(addr);
if (IsOsModule(mod))
{
profaddr = addr;
} else {
break;
}
}
for (int n=(int)stack.depth-1;n>=0;n--)
{
std::wstring file;
int line;
PROFILER_ADDR addr = stack.addr[n];
std::wstring loc = syminfo->getProcForAddr(addr, file, line);
if (IsOsFunction(loc))
{
profaddr = addr;
break;
}
}
}
}
} catch( ProfilerExcep &)
{
}
if (profaddr && syminfo)
{
std::wstring file;
int line;
// Grab the name of the current IP location.
return syminfo->getProcForAddr(profaddr, file, line);
}
return L"-";
}
void
ViewSegment::notifyRemove(ViewElement *e) const
{
Profiler profiler("ViewSegment::notifyRemove");
for (ObserverSet::const_iterator i = m_observers.begin();
i != m_observers.end(); ++i) {
(*i)->elementRemoved(this, e);
}
}
void V8ProfilerAgentImpl::setSamplingInterval(ErrorString* error, int interval)
{
if (m_recordingCPUProfile) {
*error = "Cannot change sampling interval when profiling.";
return;
}
m_state->setInteger(ProfilerAgentState::samplingInterval, interval);
profiler()->SetSamplingInterval(interval);
}
void GLModelRenderer::RenderSunlightPass() {
SPADES_MARK_FUNCTION();
GLProfiler profiler(device, "Model [%d model(s), %d unique model type(s)]", modelCount, (int)models.size());
for(size_t i = 0; i < models.size(); i++){
RenderModel& m = models[i];
GLModel *model = m.model;
model->RenderSunlightPass(m.params);
}
}
void LightManager::updateLights(const Frustum<float> &frustum)
{
ScopeProfiler profiler("3d", "updateLights");
lightOctreeManager->refreshOctreeables();
lightsInFrustum.clear();
lightOctreeManager->getOctreeablesIn(frustum, lightsInFrustum);
visibleLights.clear();
visibleLights = parallelBeamsLights;
visibleLights.insert(visibleLights.end(), lightsInFrustum.begin(), lightsInFrustum.end());
}
std::unique_ptr<protocol::Profiler::CPUProfile> V8ProfilerAgentImpl::stopProfiling(const String16& title, bool serialize)
{
v8::HandleScope handleScope(m_isolate);
v8::CpuProfile* profile = profiler()->StopProfiling(toV8String(m_isolate, title));
if (!profile)
return nullptr;
std::unique_ptr<protocol::Profiler::CPUProfile> result;
if (serialize)
result = createCPUProfile(m_isolate, profile);
profile->Delete();
return result;
}
void
MatrixFile::initialise()
{
Profiler profiler("MatrixFile::initialise", true);
assert(m_mode == WriteOnly);
m_setColumns = new ResizeableBitset(m_width);
off_t off = m_headerSize + (m_width * m_height * m_cellSize) + m_width;
#ifdef DEBUG_MATRIX_FILE
std::cerr << "MatrixFile[" << m_fd << "]::initialise(" << m_width << ", " << m_height << "): cell size " << m_cellSize << ", header size " << m_headerSize << ", resizing file" << std::endl;
#endif
if (::lseek(m_fd, off - 1, SEEK_SET) < 0) {
::perror("ERROR: MatrixFile::initialise: seek to end failed");
throw FileOperationFailed(m_fileName, "lseek");
}
unsigned char byte = 0;
if (::write(m_fd, &byte, 1) != 1) {
::perror("ERROR: MatrixFile::initialise: write at end failed");
throw FileOperationFailed(m_fileName, "write");
}
if (::lseek(m_fd, 0, SEEK_SET) < 0) {
::perror("ERROR: MatrixFile::initialise: Seek to write header failed");
throw FileOperationFailed(m_fileName, "lseek");
}
size_t header[2];
header[0] = m_width;
header[1] = m_height;
if (::write(m_fd, header, 2 * sizeof(size_t)) != 2 * sizeof(size_t)) {
::perror("ERROR: MatrixFile::initialise: Failed to write header");
throw FileOperationFailed(m_fileName, "write");
}
if (m_mode == WriteOnly) {
totalStorage += (m_headerSize + (m_width * m_height * m_cellSize) + m_width);
}
#ifdef DEBUG_MATRIX_FILE
std::cerr << "MatrixFile[" << m_fd << "]::initialise(" << m_width << ", " << m_height << "): storage "
<< (m_headerSize + m_width * m_height * m_cellSize + m_width) << std::endl;
std::cerr << "MatrixFile: Total storage " << totalStorage/1024 << "K" << std::endl;
#endif
seekTo(0);
}
void
ViewSegment::eventAdded(const Segment *t, Event *e)
{
Profiler profiler("ViewSegment::eventAdded");
Q_ASSERT(t == &m_segment);
(void)t; // avoid warnings
if (wrapEvent(e)) {
ViewElement *el = makeViewElement(e);
m_viewElementList->insert(el);
notifyAdd(el);
}
}
void GLBasicShadowMapRenderer::Render() {
SPADES_MARK_FUNCTION();
IGLDevice::Integer lastFb = device->GetInteger(IGLDevice::FramebufferBinding);
// client::SceneDefinition def = GetRenderer()->GetSceneDef();
float nearDist = 0.f;
for (int i = 0; i < NumSlices; i++) {
GLProfiler::Context profiler(GetRenderer()->GetGLProfiler(), "Slice %d / %d", i + 1, (int)NumSlices);
float farDist = 0.0;
// TODO: variable far distance according to the scene definition
// (note that this needs uniform shader variable)
switch (i) {
case 0: farDist = 12.f; break;
case 1: farDist = 40.f; break;
case 2: farDist = 150.f; break;
}
BuildMatrix(nearDist, farDist);
matrices[i] = matrix;
/*
printf("m[%d]=\n[%f,%f,%f,%f]\n[%f,%f,%f,%f]\n[%f,%f,%f,%f]\n[%f,%f,%f,%f]\n",
i, matrix.m[0], matrix.m[4], matrix.m[8], matrix.m[12],
matrix.m[1], matrix.m[5], matrix.m[9], matrix.m[13],
matrix.m[2], matrix.m[6], matrix.m[10], matrix.m[14],
matrix.m[3], matrix.m[7], matrix.m[11], matrix.m[15]);*/
/*
matrix = Matrix4::Identity();
matrix = Matrix4::Scale(1.f / 16.f);
matrix = matrix * Matrix4::Rotate(MakeVector3(1, 0, 0), M_PI / 4.f);
matrix = matrix * Matrix4::Translate(-def.viewOrigin);
matrix = Matrix4::Scale(1,1,16.f / 70.f) * matrix;*/
device->BindFramebuffer(IGLDevice::Framebuffer, framebuffer[i]);
device->Viewport(0, 0, textureSize, textureSize);
device->ClearDepth(1.f);
device->Clear(IGLDevice::DepthBufferBit);
RenderShadowMapPass();
nearDist = farDist;
}
device->BindFramebuffer(IGLDevice::Framebuffer, lastFb);
device->Viewport(0, 0, device->ScreenWidth(), device->ScreenHeight());
}
// Called by choreographer to do an RT-driven animation
void CanvasContext::doFrame() {
if (CC_UNLIKELY(!mCanvas || mEglSurface == EGL_NO_SURFACE)) {
return;
}
ATRACE_CALL();
profiler().startFrame();
TreeInfo info(TreeInfo::MODE_RT_ONLY, mRenderThread.renderState());
prepareTree(info);
if (info.out.canDrawThisFrame) {
draw();
}
}
void GLModelRenderer::RenderShadowMapPass() {
SPADES_MARK_FUNCTION();
GLProfiler profiler(device, "Model [%d model(s), %d unique model type(s)]", modelCount, (int)models.size());
int numModels = 0;
for(size_t i = 0; i < models.size(); i++){
RenderModel& m = models[i];
GLModel *model = m.model;
model->RenderShadowMapPass(m.params);
numModels += (int)m.params.size();
}
#if 0
printf("Model types: %d, Number of models: %d\n",
(int)models.size(), numModels);
#endif
}
void GLRadiosityRenderer::Update() {
if (GetNumDirtyChunks() > 0 && (dispatch == NULL || dispatch->done.load())) {
if (dispatch) {
dispatch->Join();
delete dispatch;
}
dispatch = new UpdateDispatch(this);
dispatch->Start();
}
int cnt = 0;
for (size_t i = 0; i < chunks.size(); i++) {
if (!chunks[i].transferDone.load())
cnt++;
}
GLProfiler::Context profiler(renderer->GetGLProfiler(), "Radiosity [>= %d chunk(s)]", cnt);
for (size_t i = 0; i < chunks.size(); i++) {
Chunk &c = chunks[i];
if (!c.transferDone.exchange(true)) {
device->BindTexture(IGLDevice::Texture3D, textureFlat);
device->TexSubImage3D(IGLDevice::Texture3D, 0, c.cx * ChunkSize,
c.cy * ChunkSize, c.cz * ChunkSize, ChunkSize, ChunkSize,
ChunkSize, IGLDevice::BGRA,
IGLDevice::UnsignedInt2101010Rev, c.dataFlat);
device->BindTexture(IGLDevice::Texture3D, textureX);
device->TexSubImage3D(IGLDevice::Texture3D, 0, c.cx * ChunkSize,
c.cy * ChunkSize, c.cz * ChunkSize, ChunkSize, ChunkSize,
ChunkSize, IGLDevice::BGRA,
IGLDevice::UnsignedInt2101010Rev, c.dataX);
device->BindTexture(IGLDevice::Texture3D, textureY);
device->TexSubImage3D(IGLDevice::Texture3D, 0, c.cx * ChunkSize,
c.cy * ChunkSize, c.cz * ChunkSize, ChunkSize, ChunkSize,
ChunkSize, IGLDevice::BGRA,
IGLDevice::UnsignedInt2101010Rev, c.dataY);
device->BindTexture(IGLDevice::Texture3D, textureZ);
device->TexSubImage3D(IGLDevice::Texture3D, 0, c.cx * ChunkSize,
c.cy * ChunkSize, c.cz * ChunkSize, ChunkSize, ChunkSize,
ChunkSize, IGLDevice::BGRA,
IGLDevice::UnsignedInt2101010Rev, c.dataZ);
}
}
}
void V8ProfilerAgentImpl::restore()
{
DCHECK(!m_enabled);
if (!m_state->booleanProperty(ProfilerAgentState::profilerEnabled, false))
return;
m_enabled = true;
#if ENSURE_V8_VERSION(5, 4)
DCHECK(!m_profiler);
m_profiler = v8::CpuProfiler::New(m_isolate);
#endif
int interval = 0;
m_state->getInteger(ProfilerAgentState::samplingInterval, &interval);
if (interval)
profiler()->SetSamplingInterval(interval);
if (m_state->booleanProperty(ProfilerAgentState::userInitiatedProfiling, false)) {
ErrorString error;
start(&error);
}
}
void
ViewSegment::eventRemoved(const Segment *t, Event *e)
{
Profiler profiler("ViewSegment::eventRemoved");
Q_ASSERT(t == &m_segment);
(void)t; // avoid warnings
// If we have it, lose it
ViewElementList::iterator i = findEvent(e);
if (i != m_viewElementList->end()) {
notifyRemove(*i);
m_viewElementList->erase(i);
return;
}
// std::cerr << "Event at " << e->getAbsoluteTime() << ", notation time " << e->getNotationAbsoluteTime() << ", type " << e->getType()
// << " not found in ViewSegment" << std::endl;
}
void
FFTMemoryCache::setColumnAt(size_t x, float *reals, float *imags)
{
Profiler profiler("FFTMemoryCache::setColumnAt: from cart");
float max = 0.0;
switch (m_storageType) {
case FFTCache::Rectangular:
for (size_t y = 0; y < m_height; ++y) {
m_freal[x][y] = reals[y];
m_fimag[x][y] = imags[y];
float mag = sqrtf(reals[y] * reals[y] + imags[y] * imags[y]);
if (mag > max) max = mag;
}
break;
case FFTCache::Compact:
case FFTCache::Polar:
{
Profiler subprof("FFTMemoryCache::setColumnAt: cart to polar");
for (size_t y = 0; y < m_height; ++y) {
float mag = sqrtf(reals[y] * reals[y] + imags[y] * imags[y]);
float phase = atan2f(imags[y], reals[y]);
reals[y] = mag;
imags[y] = phase;
if (mag > max) max = mag;
}
break;
}
};
if (m_storageType == FFTCache::Rectangular) {
m_factor[x] = max;
m_colsetLock.lockForWrite();
m_colset.set(x);
m_colsetLock.unlock();
} else {
setColumnAt(x, reals, imags, max);
}
}
