/** * @file llfloatersnapshot.cpp * @brief Snapshot preview window, allowing saving, e-mailing, etc. * * $LicenseInfo:firstyear=2004&license=viewergpl$ * * Copyright (c) 2004-2007, Linden Research, Inc. * * Second Life Viewer Source Code * The source code in this file ("Source Code") is provided by Linden Lab * to you under the terms of the GNU General Public License, version 2.0 * ("GPL"), unless you have obtained a separate licensing agreement * ("Other License"), formally executed by you and Linden Lab. Terms of * the GPL can be found in doc/GPL-license.txt in this distribution, or * online at http://secondlife.com/developers/opensource/gplv2 * * There are special exceptions to the terms and conditions of the GPL as * it is applied to this Source Code. View the full text of the exception * in the file doc/FLOSS-exception.txt in this software distribution, or * online at http://secondlife.com/developers/opensource/flossexception * * By copying, modifying or distributing this software, you acknowledge * that you have read and understood your obligations described above, * and agree to abide by those obligations. * * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY, * COMPLETENESS OR PERFORMANCE. * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "llfloatersnapshot.h" #include "llfontgl.h" #include "llsys.h" #include "llgl.h" #include "llrender.h" #include "v3dmath.h" #include "llmath.h" #include "lldir.h" #include "llsdserialize.h" #include "llagent.h" #include "llcallbacklist.h" #include "llcriticaldamp.h" #include "llui.h" #include "llviewertexteditor.h" #include "llfocusmgr.h" #include "llbutton.h" #include "llcombobox.h" #include "llsliderctrl.h" #include "llspinctrl.h" #include "llviewercontrol.h" #include "lluictrlfactory.h" #include "llviewerstats.h" #include "llviewercamera.h" #include "llviewerwindow.h" #include "llviewermenufile.h" // upload_new_resource() #include "llfloaterpostcard.h" #include "llcheckboxctrl.h" #include "llradiogroup.h" #include "lltoolfocus.h" #include "lltoolmgr.h" #include "llworld.h" #include "llgl.h" #include "llglheaders.h" #include "llimagejpeg.h" #include "llimagej2c.h" #include "llvfile.h" #include "llvfs.h" ///---------------------------------------------------------------------------- /// Local function declarations, constants, enums, and typedefs ///---------------------------------------------------------------------------- S32 LLFloaterSnapshot::sUIWinHeightLong = 526 ; S32 LLFloaterSnapshot::sUIWinHeightShort = LLFloaterSnapshot::sUIWinHeightLong - 230 ; S32 LLFloaterSnapshot::sUIWinWidth = 215 ; LLSnapshotFloaterView* gSnapshotFloaterView = NULL; LLFloaterSnapshot* LLFloaterSnapshot::sInstance = NULL; const F32 SNAPSHOT_TIME_DELAY = 1.f; F32 SHINE_TIME = 0.5f; F32 SHINE_WIDTH = 0.6f; F32 SHINE_OPACITY = 0.3f; F32 FALL_TIME = 0.6f; S32 BORDER_WIDTH = 6; const S32 MAX_POSTCARD_DATASIZE = 1024 * 1024; // one megabyte const S32 MAX_TEXTURE_SIZE = 512 ; //max upload texture size 512 * 512 ///---------------------------------------------------------------------------- /// Class LLSnapshotLivePreview ///---------------------------------------------------------------------------- class LLSnapshotLivePreview : public LLView { public: enum ESnapshotType { SNAPSHOT_POSTCARD, SNAPSHOT_TEXTURE, SNAPSHOT_BITMAP }; LLSnapshotLivePreview(const LLRect& rect); ~LLSnapshotLivePreview(); /*virtual*/ void draw(); /*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent); void setSize(S32 w, S32 h); void getSize(S32& w, S32& h) const; S32 getDataSize() const { return mDataSize; } void setMaxImageSize(S32 size) ; S32 getMaxImageSize() {return mMaxImageSize ;} ESnapshotType getSnapshotType() const { return mSnapshotType; } BOOL getSnapshotUpToDate() const { return mSnapshotUpToDate; } BOOL isSnapshotActive() { return mSnapshotActive; } LLImageGL* getThumbnailImage() const { return mThumbnailImage ; } S32 getThumbnailWidth() const { return mThumbnailWidth ; } S32 getThumbnailHeight() const { return mThumbnailHeight ; } BOOL getThumbnailLock() const { return mThumbnailUpdateLock ; } BOOL getThumbnailUpToDate() const { return mThumbnailUpToDate ;} LLImageGL* getCurrentImage(); F32 getImageAspect(); F32 getAspect() ; LLRect getImageRect(); BOOL isImageScaled(); void setSnapshotType(ESnapshotType type) { mSnapshotType = type; } void setSnapshotQuality(S32 quality); void setSnapshotBufferType(LLViewerWindow::ESnapshotType type) { mSnapshotBufferType = type; } void updateSnapshot(BOOL new_snapshot, BOOL new_thumbnail = FALSE); LLFloaterPostcard* savePostcard(); void saveTexture(); BOOL saveLocal(); BOOL setThumbnailImageSize() ; void generateThumbnailImage(BOOL force_update = FALSE) ; void resetThumbnailImage() { mThumbnailImage = NULL ; } void drawPreviewRect(S32 offset_x, S32 offset_y) ; static void onIdle( void* snapshot_preview ); protected: LLColor4 mColor; LLPointer mViewerImage[2]; LLRect mImageRect[2]; S32 mWidth[2]; S32 mHeight[2]; BOOL mImageScaled[2]; S32 mMaxImageSize ; //thumbnail image LLPointer mThumbnailImage ; S32 mThumbnailWidth ; S32 mThumbnailHeight ; LLRect mPreviewRect ; BOOL mThumbnailUpdateLock ; BOOL mThumbnailUpToDate ; S32 mCurImageIndex; LLPointer mRawImage; LLPointer mRawImageEncoded; LLPointer mJPEGImage; LLFrameTimer mSnapshotDelayTimer; S32 mShineCountdown; LLFrameTimer mShineAnimTimer; F32 mFlashAlpha; BOOL mNeedsFlash; LLVector3d mPosTakenGlobal; S32 mSnapshotQuality; S32 mDataSize; ESnapshotType mSnapshotType; BOOL mSnapshotUpToDate; LLFrameTimer mFallAnimTimer; LLVector3 mCameraPos; LLQuaternion mCameraRot; BOOL mSnapshotActive; LLViewerWindow::ESnapshotType mSnapshotBufferType; bool mSnapshotSoundPlayed; public: static std::set sList; BOOL mKeepAspectRatio ; }; std::set LLSnapshotLivePreview::sList; LLSnapshotLivePreview::LLSnapshotLivePreview (const LLRect& rect) : LLView(std::string("snapshot_live_preview"), rect, FALSE), mColor(1.f, 0.f, 0.f, 0.5f), mCurImageIndex(0), mRawImage(NULL), mThumbnailImage(NULL) , mRawImageEncoded(NULL), mJPEGImage(NULL), mShineCountdown(0), mFlashAlpha(0.f), mNeedsFlash(TRUE), mSnapshotQuality(gSavedSettings.getS32("SnapshotQuality")), mDataSize(0), mSnapshotType(SNAPSHOT_POSTCARD), mSnapshotUpToDate(FALSE), mCameraPos(LLViewerCamera::getInstance()->getOrigin()), mCameraRot(LLViewerCamera::getInstance()->getQuaternion()), mSnapshotActive(FALSE), mSnapshotBufferType(LLViewerWindow::SNAPSHOT_TYPE_COLOR), mSnapshotSoundPlayed(false) { mSnapshotDelayTimer.setTimerExpirySec(0.0f); mSnapshotDelayTimer.start(); // gIdleCallbacks.addFunction( &LLSnapshotLivePreview::onIdle, (void*)this ); sList.insert(this); setFollowsAll(); mWidth[0] = gViewerWindow->getWindowDisplayWidth(); mWidth[1] = gViewerWindow->getWindowDisplayWidth(); mHeight[0] = gViewerWindow->getWindowDisplayHeight(); mHeight[1] = gViewerWindow->getWindowDisplayHeight(); mImageScaled[0] = FALSE; mImageScaled[1] = FALSE; mMaxImageSize = MAX_IMAGE_SIZE ; mKeepAspectRatio = gSavedSettings.getBOOL("KeepAspectForSnapshot") ; mThumbnailUpdateLock = FALSE ; mThumbnailUpToDate = FALSE ; } LLSnapshotLivePreview::~LLSnapshotLivePreview() { // delete images mRawImage = NULL; mRawImageEncoded = NULL; mJPEGImage = NULL; // gIdleCallbacks.deleteFunction( &LLSnapshotLivePreview::onIdle, (void*)this ); sList.erase(this); } void LLSnapshotLivePreview::setMaxImageSize(S32 size) { if(size < MAX_IMAGE_SIZE) { mMaxImageSize = size; } else { mMaxImageSize = MAX_IMAGE_SIZE ; } } LLImageGL* LLSnapshotLivePreview::getCurrentImage() { return mViewerImage[mCurImageIndex]; } F32 LLSnapshotLivePreview::getAspect() { F32 image_aspect_ratio = ((F32)mWidth[mCurImageIndex]) / ((F32)mHeight[mCurImageIndex]); F32 window_aspect_ratio = ((F32)getRect().getWidth()) / ((F32)getRect().getHeight()); if (!mKeepAspectRatio)//gSavedSettings.getBOOL("KeepAspectForSnapshot")) { return image_aspect_ratio; } else { return window_aspect_ratio; } } F32 LLSnapshotLivePreview::getImageAspect() { if (!mViewerImage[mCurImageIndex]) { return 0.f; } return getAspect() ; } LLRect LLSnapshotLivePreview::getImageRect() { return mImageRect[mCurImageIndex]; } BOOL LLSnapshotLivePreview::isImageScaled() { return mImageScaled[mCurImageIndex]; } void LLSnapshotLivePreview::updateSnapshot(BOOL new_snapshot, BOOL new_thumbnail) { if (mSnapshotUpToDate) { S32 old_image_index = mCurImageIndex; mCurImageIndex = (mCurImageIndex + 1) % 2; mWidth[mCurImageIndex] = mWidth[old_image_index]; mHeight[mCurImageIndex] = mHeight[old_image_index]; mFallAnimTimer.start(); } mSnapshotUpToDate = FALSE; LLRect& rect = mImageRect[mCurImageIndex]; rect.set(0, getRect().getHeight(), getRect().getWidth(), 0); F32 image_aspect_ratio = ((F32)mWidth[mCurImageIndex]) / ((F32)mHeight[mCurImageIndex]); F32 window_aspect_ratio = ((F32)getRect().getWidth()) / ((F32)getRect().getHeight()); if (mKeepAspectRatio)//gSavedSettings.getBOOL("KeepAspectForSnapshot")) { if (image_aspect_ratio > window_aspect_ratio) { // trim off top and bottom S32 new_height = llround((F32)getRect().getWidth() / image_aspect_ratio); rect.mBottom += (getRect().getHeight() - new_height) / 2; rect.mTop -= (getRect().getHeight() - new_height) / 2; } else if (image_aspect_ratio < window_aspect_ratio) { // trim off left and right S32 new_width = llround((F32)getRect().getHeight() * image_aspect_ratio); rect.mLeft += (getRect().getWidth() - new_width) / 2; rect.mRight -= (getRect().getWidth() - new_width) / 2; } } mShineAnimTimer.stop(); if (new_snapshot) { mSnapshotDelayTimer.start(); mSnapshotDelayTimer.setTimerExpirySec(SNAPSHOT_TIME_DELAY); } else if(new_thumbnail) { mThumbnailUpToDate = FALSE ; } else { setThumbnailImageSize() ; } } void LLSnapshotLivePreview::setSnapshotQuality(S32 quality) { if (quality != mSnapshotQuality) { mSnapshotQuality = quality; gSavedSettings.setS32("SnapshotQuality", quality); } } void LLSnapshotLivePreview::drawPreviewRect(S32 offset_x, S32 offset_y) { F32 line_width ; glGetFloatv(GL_LINE_WIDTH, &line_width) ; glLineWidth(2.0f * line_width) ; LLColor4 color(0.0f, 0.0f, 0.0f, 1.0f) ; gl_rect_2d( mPreviewRect.mLeft + offset_x, mPreviewRect.mTop + offset_y, mPreviewRect.mRight + offset_x, mPreviewRect.mBottom + offset_y, color, FALSE ) ; glLineWidth(line_width) ; //draw four alpha rectangles to cover areas outside of the snapshot image if(!mKeepAspectRatio) { LLColor4 alpha_color(0.5f, 0.5f, 0.5f, 0.8f) ; S32 dwl = 0, dwr = 0 ; if(mThumbnailWidth > mPreviewRect.getWidth()) { dwl = (mThumbnailWidth - mPreviewRect.getWidth()) >> 1 ; dwr = mThumbnailWidth - mPreviewRect.getWidth() - dwl ; gl_rect_2d(mPreviewRect.mLeft + offset_x - dwl, mPreviewRect.mTop + offset_y, mPreviewRect.mLeft + offset_x, mPreviewRect.mBottom + offset_y, alpha_color, TRUE ) ; gl_rect_2d( mPreviewRect.mRight + offset_x, mPreviewRect.mTop + offset_y, mPreviewRect.mRight + offset_x + dwr, mPreviewRect.mBottom + offset_y, alpha_color, TRUE ) ; } if(mThumbnailHeight > mPreviewRect.getHeight()) { S32 dh = (mThumbnailHeight - mPreviewRect.getHeight()) >> 1 ; gl_rect_2d(mPreviewRect.mLeft + offset_x - dwl, mPreviewRect.mBottom + offset_y , mPreviewRect.mRight + offset_x + dwr, mPreviewRect.mBottom + offset_y - dh, alpha_color, TRUE ) ; dh = mThumbnailHeight - mPreviewRect.getHeight() - dh ; gl_rect_2d( mPreviewRect.mLeft + offset_x - dwl, mPreviewRect.mTop + offset_y + dh, mPreviewRect.mRight + offset_x + dwr, mPreviewRect.mTop + offset_y, alpha_color, TRUE ) ; } } } void LLSnapshotLivePreview::draw() { if (mViewerImage[mCurImageIndex].notNull() && mRawImageEncoded.notNull() && mSnapshotUpToDate) { LLColor4 bg_color(0.f, 0.f, 0.3f, 0.4f); gl_rect_2d(getRect(), bg_color); LLRect &rect = mImageRect[mCurImageIndex]; LLRect shadow_rect = mImageRect[mCurImageIndex]; shadow_rect.stretch(BORDER_WIDTH); gl_drop_shadow(shadow_rect.mLeft, shadow_rect.mTop, shadow_rect.mRight, shadow_rect.mBottom, LLColor4(0.f, 0.f, 0.f, mNeedsFlash ? 0.f :0.5f), 10); LLColor4 image_color(1.f, 1.f, 1.f, 1.f); gGL.color4fv(image_color.mV); LLViewerImage::bindTexture(mViewerImage[mCurImageIndex]); // calculate UV scale F32 uv_width = mImageScaled[mCurImageIndex] ? 1.f : llmin((F32)mWidth[mCurImageIndex] / (F32)mViewerImage[mCurImageIndex]->getWidth(), 1.f); F32 uv_height = mImageScaled[mCurImageIndex] ? 1.f : llmin((F32)mHeight[mCurImageIndex] / (F32)mViewerImage[mCurImageIndex]->getHeight(), 1.f); glPushMatrix(); { glTranslatef((F32)rect.mLeft, (F32)rect.mBottom, 0.f); gGL.begin(LLVertexBuffer::QUADS); { gGL.texCoord2f(uv_width, uv_height); gGL.vertex2i(rect.getWidth(), rect.getHeight() ); gGL.texCoord2f(0.f, uv_height); gGL.vertex2i(0, rect.getHeight() ); gGL.texCoord2f(0.f, 0.f); gGL.vertex2i(0, 0); gGL.texCoord2f(uv_width, 0.f); gGL.vertex2i(rect.getWidth(), 0); } gGL.end(); } glPopMatrix(); gGL.color4f(1.f, 1.f, 1.f, mFlashAlpha); gl_rect_2d(getRect()); if (mNeedsFlash) { if (mFlashAlpha < 1.f) { mFlashAlpha = lerp(mFlashAlpha, 1.f, LLCriticalDamp::getInterpolant(0.02f)); } else { mNeedsFlash = FALSE; } } else { mFlashAlpha = lerp(mFlashAlpha, 0.f, LLCriticalDamp::getInterpolant(0.15f)); } if (mShineCountdown > 0) { mShineCountdown--; if (mShineCountdown == 0) { mShineAnimTimer.start(); } } else if (mShineAnimTimer.getStarted()) { //LLDebugVarMessageBox::show("Shine time", &SHINE_TIME, 10.f, 0.1f); //LLDebugVarMessageBox::show("Shine width", &SHINE_WIDTH, 2.f, 0.05f); //LLDebugVarMessageBox::show("Shine opacity", &SHINE_OPACITY, 1.f, 0.05f); F32 shine_interp = llmin(1.f, mShineAnimTimer.getElapsedTimeF32() / SHINE_TIME); // draw "shine" effect LLLocalClipRect clip(getLocalRect()); { // draw diagonal stripe with gradient that passes over screen S32 x1 = gViewerWindow->getWindowWidth() * llround((clamp_rescale(shine_interp, 0.f, 1.f, -1.f - SHINE_WIDTH, 1.f))); S32 x2 = x1 + llround(gViewerWindow->getWindowWidth() * SHINE_WIDTH); S32 x3 = x2 + llround(gViewerWindow->getWindowWidth() * SHINE_WIDTH); S32 y1 = 0; S32 y2 = gViewerWindow->getWindowHeight(); LLGLSNoTexture no_texture; gGL.begin(LLVertexBuffer::QUADS); { gGL.color4f(1.f, 1.f, 1.f, 0.f); gGL.vertex2i(x1, y1); gGL.vertex2i(x1 + gViewerWindow->getWindowWidth(), y2); gGL.color4f(1.f, 1.f, 1.f, SHINE_OPACITY); gGL.vertex2i(x2 + gViewerWindow->getWindowWidth(), y2); gGL.vertex2i(x2, y1); gGL.color4f(1.f, 1.f, 1.f, SHINE_OPACITY); gGL.vertex2i(x2, y1); gGL.vertex2i(x2 + gViewerWindow->getWindowWidth(), y2); gGL.color4f(1.f, 1.f, 1.f, 0.f); gGL.vertex2i(x3 + gViewerWindow->getWindowWidth(), y2); gGL.vertex2i(x3, y1); } gGL.end(); } if (mShineAnimTimer.getElapsedTimeF32() > SHINE_TIME) { mShineAnimTimer.stop(); } } } // draw framing rectangle { LLGLSNoTexture no_texture; gGL.color4f(1.f, 1.f, 1.f, 1.f); LLRect outline_rect = mImageRect[mCurImageIndex]; gGL.begin(LLVertexBuffer::QUADS); { gGL.vertex2i(outline_rect.mLeft - BORDER_WIDTH, outline_rect.mTop + BORDER_WIDTH); gGL.vertex2i(outline_rect.mRight + BORDER_WIDTH, outline_rect.mTop + BORDER_WIDTH); gGL.vertex2i(outline_rect.mRight, outline_rect.mTop); gGL.vertex2i(outline_rect.mLeft, outline_rect.mTop); gGL.vertex2i(outline_rect.mLeft, outline_rect.mBottom); gGL.vertex2i(outline_rect.mRight, outline_rect.mBottom); gGL.vertex2i(outline_rect.mRight + BORDER_WIDTH, outline_rect.mBottom - BORDER_WIDTH); gGL.vertex2i(outline_rect.mLeft - BORDER_WIDTH, outline_rect.mBottom - BORDER_WIDTH); gGL.vertex2i(outline_rect.mLeft, outline_rect.mTop); gGL.vertex2i(outline_rect.mLeft, outline_rect.mBottom); gGL.vertex2i(outline_rect.mLeft - BORDER_WIDTH, outline_rect.mBottom - BORDER_WIDTH); gGL.vertex2i(outline_rect.mLeft - BORDER_WIDTH, outline_rect.mTop + BORDER_WIDTH); gGL.vertex2i(outline_rect.mRight, outline_rect.mBottom); gGL.vertex2i(outline_rect.mRight, outline_rect.mTop); gGL.vertex2i(outline_rect.mRight + BORDER_WIDTH, outline_rect.mTop + BORDER_WIDTH); gGL.vertex2i(outline_rect.mRight + BORDER_WIDTH, outline_rect.mBottom - BORDER_WIDTH); } gGL.end(); } // draw old image dropping away if (mFallAnimTimer.getStarted()) { S32 old_image_index = (mCurImageIndex + 1) % 2; if (mViewerImage[old_image_index].notNull() && mFallAnimTimer.getElapsedTimeF32() < FALL_TIME) { F32 fall_interp = mFallAnimTimer.getElapsedTimeF32() / FALL_TIME; F32 alpha = clamp_rescale(fall_interp, 0.f, 1.f, 0.8f, 0.4f); LLColor4 image_color(1.f, 1.f, 1.f, alpha); gGL.color4fv(image_color.mV); LLViewerImage::bindTexture(mViewerImage[old_image_index]); // calculate UV scale // *FIX get this to work with old image BOOL rescale = !mImageScaled[old_image_index] && mViewerImage[mCurImageIndex].notNull(); F32 uv_width = rescale ? llmin((F32)mWidth[old_image_index] / (F32)mViewerImage[mCurImageIndex]->getWidth(), 1.f) : 1.f; F32 uv_height = rescale ? llmin((F32)mHeight[old_image_index] / (F32)mViewerImage[mCurImageIndex]->getHeight(), 1.f) : 1.f; glPushMatrix(); { LLRect& rect = mImageRect[old_image_index]; glTranslatef((F32)rect.mLeft, (F32)rect.mBottom - llround(getRect().getHeight() * 2.f * (fall_interp * fall_interp)), 0.f); glRotatef(-45.f * fall_interp, 0.f, 0.f, 1.f); gGL.begin(LLVertexBuffer::QUADS); { gGL.texCoord2f(uv_width, uv_height); gGL.vertex2i(rect.getWidth(), rect.getHeight() ); gGL.texCoord2f(0.f, uv_height); gGL.vertex2i(0, rect.getHeight() ); gGL.texCoord2f(0.f, 0.f); gGL.vertex2i(0, 0); gGL.texCoord2f(uv_width, 0.f); gGL.vertex2i(rect.getWidth(), 0); } gGL.end(); } glPopMatrix(); } } } /*virtual*/ void LLSnapshotLivePreview::reshape(S32 width, S32 height, BOOL called_from_parent) { LLRect old_rect = getRect(); LLView::reshape(width, height, called_from_parent); if (old_rect.getWidth() != width || old_rect.getHeight() != height) { updateSnapshot(FALSE, TRUE); } } BOOL LLSnapshotLivePreview::setThumbnailImageSize() { if(mWidth[mCurImageIndex] < 10 || mHeight[mCurImageIndex] < 10) { return FALSE ; } S32 window_width = gViewerWindow->getWindowDisplayWidth() ; S32 window_height = gViewerWindow->getWindowDisplayHeight() ; F32 window_aspect_ratio = ((F32)window_width) / ((F32)window_height); // UI size for thumbnail S32 max_width = LLFloaterSnapshot::getUIWinWidth() - 20; S32 max_height = 90; if (window_aspect_ratio > (F32)max_width / max_height) { // image too wide, shrink to width mThumbnailWidth = max_width; mThumbnailHeight = llround((F32)max_width / window_aspect_ratio); } else { // image too tall, shrink to height mThumbnailHeight = max_height; mThumbnailWidth = llround((F32)max_height * window_aspect_ratio); } if(mThumbnailWidth > window_width || mThumbnailHeight > window_height) { return FALSE ;//if the window is too small, ignore thumbnail updating. } S32 left = 0 , top = mThumbnailHeight, right = mThumbnailWidth, bottom = 0 ; if(!mKeepAspectRatio) { F32 ratio_x = (F32)mWidth[mCurImageIndex] / window_width ; F32 ratio_y = (F32)mHeight[mCurImageIndex] / window_height ; //if(mWidth[mCurImageIndex] > window_width || // mHeight[mCurImageIndex] > window_height ) { if(ratio_x > ratio_y) { top = (S32)(top * ratio_y / ratio_x) ; } else { right = (S32)(right * ratio_x / ratio_y) ; } } //else //{ // right = (S32)(right * ratio_x) ; // top = (S32)(top * ratio_y) ; //} left = (S32)((mThumbnailWidth - right) * 0.5f) ; bottom = (S32)((mThumbnailHeight - top) * 0.5f) ; top += bottom ; right += left ; } mPreviewRect.set(left - 1, top + 1, right + 1, bottom - 1) ; return TRUE ; } void LLSnapshotLivePreview::generateThumbnailImage(BOOL force_update) { if(mThumbnailUpdateLock) //in the process of updating { return ; } if(mThumbnailUpToDate && !force_update)//already updated { return ; } if(mWidth[mCurImageIndex] < 10 || mHeight[mCurImageIndex] < 10) { return ; } ////lock updating mThumbnailUpdateLock = TRUE ; if(!setThumbnailImageSize()) { mThumbnailUpdateLock = FALSE ; mThumbnailUpToDate = TRUE ; return ; } if(mThumbnailImage) { resetThumbnailImage() ; } LLPointer raw = NULL ; S32 w , h ; w = get_nearest_power_two(mThumbnailWidth, 512) * 2 ; h = get_nearest_power_two(mThumbnailHeight, 512) * 2 ; { raw = new LLImageRaw ; if(!gViewerWindow->thumbnailSnapshot(raw, w, h, gSavedSettings.getBOOL("RenderUIInSnapshot"), FALSE, mSnapshotBufferType) ) { raw = NULL ; } } if(raw) { mThumbnailImage = new LLImageGL(raw, FALSE); mThumbnailUpToDate = TRUE ; } //unlock updating mThumbnailUpdateLock = FALSE ; } //static void LLSnapshotLivePreview::onIdle( void* snapshot_preview ) { LLSnapshotLivePreview* previewp = (LLSnapshotLivePreview*)snapshot_preview; LLVector3 new_camera_pos = LLViewerCamera::getInstance()->getOrigin(); LLQuaternion new_camera_rot = LLViewerCamera::getInstance()->getQuaternion(); if (gSavedSettings.getBOOL("FreezeTime") && (new_camera_pos != previewp->mCameraPos || dot(new_camera_rot, previewp->mCameraRot) < 0.995f)) { previewp->mCameraPos = new_camera_pos; previewp->mCameraRot = new_camera_rot; // request a new snapshot whenever the camera moves, with a time delay previewp->updateSnapshot(gSavedSettings.getBOOL("AutoSnapshot")); } previewp->mSnapshotActive = (previewp->mSnapshotDelayTimer.getStarted() && previewp->mSnapshotDelayTimer.hasExpired()); // don't take snapshots while ALT-zoom active if (LLToolCamera::getInstance()->hasMouseCapture()) { previewp->mSnapshotActive = FALSE; } if (previewp->mSnapshotActive) { if (!previewp->mRawImage) { previewp->mRawImage = new LLImageRaw; } if (!previewp->mRawImageEncoded) { previewp->mRawImageEncoded = new LLImageRaw; } previewp->setVisible(FALSE); previewp->setEnabled(FALSE); previewp->getWindow()->incBusyCount(); previewp->mImageScaled[previewp->mCurImageIndex] = FALSE; // do update if(gViewerWindow->rawSnapshot(previewp->mRawImage, previewp->mWidth[previewp->mCurImageIndex], previewp->mHeight[previewp->mCurImageIndex], previewp->mKeepAspectRatio,//gSavedSettings.getBOOL("KeepAspectForSnapshot"), previewp->getSnapshotType() == LLSnapshotLivePreview::SNAPSHOT_TEXTURE, gSavedSettings.getBOOL("RenderUIInSnapshot"), FALSE, previewp->mSnapshotBufferType, previewp->getMaxImageSize())) { previewp->mRawImageEncoded->resize(previewp->mRawImage->getWidth(), previewp->mRawImage->getHeight(), previewp->mRawImage->getComponents()); if (!gSavedSettings.getBOOL("QuietSnapshotsToDisk")) { // Always play the sound once, on window open. // Don't keep playing if automatic // updates are enabled. It's too invasive. JC if (!previewp->mSnapshotSoundPlayed || !gSavedSettings.getBOOL("AutoSnapshot") ) { gViewerWindow->playSnapshotAnimAndSound(); previewp->mSnapshotSoundPlayed = true; } } if (previewp->getSnapshotType() == SNAPSHOT_POSTCARD) { // *FIX: just resize and reuse existing jpeg? previewp->mJPEGImage = NULL; // deletes image previewp->mJPEGImage = new LLImageJPEG(); previewp->mJPEGImage->setEncodeQuality(llclamp(previewp->mSnapshotQuality, 0, 100)); if (previewp->mJPEGImage->encode(previewp->mRawImage, 0.0f)) { previewp->mDataSize = previewp->mJPEGImage->getDataSize(); previewp->mJPEGImage->decode(previewp->mRawImageEncoded, 0.0f); } } else if (previewp->getSnapshotType() == SNAPSHOT_TEXTURE) { LLPointer formatted = new LLImageJ2C; LLPointer scaled = new LLImageRaw(previewp->mRawImage->getData(), previewp->mRawImage->getWidth(), previewp->mRawImage->getHeight(), previewp->mRawImage->getComponents()); scaled->biasedScaleToPowerOfTwo(512); previewp->mImageScaled[previewp->mCurImageIndex] = TRUE; if (formatted->encode(scaled, 0.0f)) { previewp->mDataSize = formatted->getDataSize(); formatted->decode(previewp->mRawImageEncoded, 0.0f); } } else { previewp->mRawImageEncoded->copy(previewp->mRawImage); previewp->mDataSize = previewp->mRawImage->getDataSize(); } LLPointer scaled = new LLImageRaw(previewp->mRawImageEncoded->getData(), previewp->mRawImageEncoded->getWidth(), previewp->mRawImageEncoded->getHeight(), previewp->mRawImageEncoded->getComponents()); // leave original image dimensions, just scale up texture buffer if (previewp->mRawImageEncoded->getWidth() > 1024 || previewp->mRawImageEncoded->getHeight() > 1024) { // go ahead and shrink image to appropriate power of 2 for display scaled->biasedScaleToPowerOfTwo(1024); previewp->mImageScaled[previewp->mCurImageIndex] = TRUE; } else { // expand image but keep original image data intact scaled->expandToPowerOfTwo(1024, FALSE); } previewp->mViewerImage[previewp->mCurImageIndex] = new LLImageGL(scaled, FALSE); previewp->mViewerImage[previewp->mCurImageIndex]->setMipFilterNearest(previewp->getSnapshotType() != SNAPSHOT_TEXTURE); LLViewerImage::bindTexture(previewp->mViewerImage[previewp->mCurImageIndex]); previewp->mViewerImage[previewp->mCurImageIndex]->setClamp(TRUE, TRUE); previewp->mSnapshotUpToDate = TRUE; previewp->generateThumbnailImage(TRUE) ; previewp->mPosTakenGlobal = gAgent.getCameraPositionGlobal(); previewp->mShineCountdown = 4; // wait a few frames to avoid animation glitch due to readback this frame } previewp->getWindow()->decBusyCount(); // only show fullscreen preview when in freeze frame mode previewp->setVisible(gSavedSettings.getBOOL("UseFreezeFrame")); previewp->mSnapshotDelayTimer.stop(); previewp->mSnapshotActive = FALSE; } if(!previewp->getThumbnailUpToDate()) { previewp->generateThumbnailImage() ; } } void LLSnapshotLivePreview::setSize(S32 w, S32 h) { mWidth[mCurImageIndex] = w; mHeight[mCurImageIndex] = h; } void LLSnapshotLivePreview::getSize(S32& w, S32& h) const { w = mWidth[mCurImageIndex]; h = mHeight[mCurImageIndex]; } LLFloaterPostcard* LLSnapshotLivePreview::savePostcard() { // calculate and pass in image scale in case image data only use portion // of viewerimage buffer LLVector2 image_scale(1.f, 1.f); if (!isImageScaled()) { image_scale.setVec(llmin(1.f, (F32)mWidth[mCurImageIndex] / (F32)getCurrentImage()->getWidth()), llmin(1.f, (F32)mHeight[mCurImageIndex] / (F32)getCurrentImage()->getHeight())); } LLFloaterPostcard* floater = LLFloaterPostcard::showFromSnapshot(mJPEGImage, mViewerImage[mCurImageIndex], image_scale, mPosTakenGlobal); // relinquish lifetime of viewerimage and jpeg image to postcard floater mViewerImage[mCurImageIndex] = NULL; mJPEGImage = NULL; return floater; } void LLSnapshotLivePreview::saveTexture() { // gen a new uuid for this asset LLTransactionID tid; tid.generate(); LLAssetID new_asset_id = tid.makeAssetID(gAgent.getSecureSessionID()); LLPointer formatted = new LLImageJ2C; LLPointer scaled = new LLImageRaw(mRawImage->getData(), mRawImage->getWidth(), mRawImage->getHeight(), mRawImage->getComponents()); scaled->biasedScaleToPowerOfTwo(512); if (formatted->encode(scaled, 0.0f)) { LLVFile::writeFile(formatted->getData(), formatted->getDataSize(), gVFS, new_asset_id, LLAssetType::AT_TEXTURE); std::string pos_string; gAgent.buildLocationString(pos_string); std::string who_took_it; gAgent.buildFullname(who_took_it); upload_new_resource(tid, // tid LLAssetType::AT_TEXTURE, "Snapshot : " + pos_string, "Taken by " + who_took_it + " at " + pos_string, 0, LLAssetType::AT_SNAPSHOT_CATEGORY, LLInventoryType::IT_SNAPSHOT, PERM_ALL, "Snapshot : " + pos_string); } else { gViewerWindow->alertXml("ErrorEncodingSnapshot"); llwarns << "Error encoding snapshot" << llendl; } LLViewerStats::getInstance()->incStat(LLViewerStats::ST_SNAPSHOT_COUNT ); } BOOL LLSnapshotLivePreview::saveLocal() { return gViewerWindow->saveImageNumbered(mRawImage); } ///---------------------------------------------------------------------------- /// Class LLFloaterSnapshot::Impl ///---------------------------------------------------------------------------- class LLFloaterSnapshot::Impl { public: Impl() : mAvatarPauseHandles(), mLastToolset(NULL) { } ~Impl() { //unpause avatars mAvatarPauseHandles.clear(); } static void onClickDiscard(void* data); static void onClickKeep(void* data); static void onClickNewSnapshot(void* data); static void onClickAutoSnap(LLUICtrl *ctrl, void* data); //static void onClickAdvanceSnap(LLUICtrl *ctrl, void* data); static void onClickLess(void* data) ; static void onClickMore(void* data) ; static void onClickUICheck(LLUICtrl *ctrl, void* data); static void onClickHUDCheck(LLUICtrl *ctrl, void* data); static void onClickKeepOpenCheck(LLUICtrl *ctrl, void* data); static void onClickKeepAspectCheck(LLUICtrl *ctrl, void* data); static void onCommitQuality(LLUICtrl* ctrl, void* data); static void onCommitResolution(LLUICtrl* ctrl, void* data); static void onCommitFreezeFrame(LLUICtrl* ctrl, void* data); static void onCommitLayerTypes(LLUICtrl* ctrl, void*data); static void onCommitSnapshotType(LLUICtrl* ctrl, void* data); static void onCommitCustomResolution(LLUICtrl *ctrl, void* data); static void resetSnapshotSizeOnUI(LLFloaterSnapshot *view, S32 width, S32 height) ; static BOOL checkImageSize(LLSnapshotLivePreview* previewp, S32& width, S32& height, BOOL isWidthChanged, S32 max_value); static LLSnapshotLivePreview* getPreviewView(LLFloaterSnapshot *floater); static void setResolution(LLFloaterSnapshot* floater, const std::string& comboname); static void updateControls(LLFloaterSnapshot* floater); static void updateLayout(LLFloaterSnapshot* floater); static LLHandle sPreviewHandle; static BOOL sAspectRatioCheckOff ; private: static LLSnapshotLivePreview::ESnapshotType getTypeIndex(LLFloaterSnapshot* floater); static LLViewerWindow::ESnapshotType getLayerType(LLFloaterSnapshot* floater); static void comboSetCustom(LLFloaterSnapshot *floater, const std::string& comboname); static void checkAutoSnapshot(LLSnapshotLivePreview* floater, BOOL update_thumbnail = FALSE); static void checkAspectRatio(LLFloaterSnapshot *view, S32 index) ; public: std::vector mAvatarPauseHandles; LLToolset* mLastToolset; }; // static LLHandle LLFloaterSnapshot::Impl::sPreviewHandle; //static BOOL LLFloaterSnapshot::Impl::sAspectRatioCheckOff = FALSE ; // static LLSnapshotLivePreview* LLFloaterSnapshot::Impl::getPreviewView(LLFloaterSnapshot *floater) { LLSnapshotLivePreview* previewp = (LLSnapshotLivePreview*)sPreviewHandle.get(); return previewp; } // static LLSnapshotLivePreview::ESnapshotType LLFloaterSnapshot::Impl::getTypeIndex(LLFloaterSnapshot* floater) { LLSnapshotLivePreview::ESnapshotType index = LLSnapshotLivePreview::SNAPSHOT_POSTCARD; LLSD value = floater->childGetValue("snapshot_type_radio"); const std::string id = value.asString(); if (id == "postcard") index = LLSnapshotLivePreview::SNAPSHOT_POSTCARD; else if (id == "texture") index = LLSnapshotLivePreview::SNAPSHOT_TEXTURE; else if (id == "local") index = LLSnapshotLivePreview::SNAPSHOT_BITMAP; return index; } // static LLViewerWindow::ESnapshotType LLFloaterSnapshot::Impl::getLayerType(LLFloaterSnapshot* floater) { LLViewerWindow::ESnapshotType type = LLViewerWindow::SNAPSHOT_TYPE_COLOR; LLSD value = floater->childGetValue("layer_types"); const std::string id = value.asString(); if (id == "colors") type = LLViewerWindow::SNAPSHOT_TYPE_COLOR; else if (id == "depth") type = LLViewerWindow::SNAPSHOT_TYPE_DEPTH; else if (id == "objects") type = LLViewerWindow::SNAPSHOT_TYPE_OBJECT_ID; return type; } // static void LLFloaterSnapshot::Impl::setResolution(LLFloaterSnapshot* floater, const std::string& comboname) { LLComboBox* combo = floater->getChild(comboname); if (combo) { combo->setVisible(TRUE); onCommitResolution(combo, floater); } } //static void LLFloaterSnapshot::Impl::updateLayout(LLFloaterSnapshot* floaterp) { LLSnapshotLivePreview* previewp = getPreviewView(floaterp); S32 delta_height = gSavedSettings.getBOOL("AdvanceSnapshot") ? 0 : floaterp->getUIWinHeightShort() - floaterp->getUIWinHeightLong() ; LLComboBox* combo; if(!gSavedSettings.getBOOL("AdvanceSnapshot")) //set to original window resolution { previewp->mKeepAspectRatio = TRUE ; combo = floaterp->getChild("postcard_size_combo"); combo->setCurrentByIndex(0) ; gSavedSettings.setS32("SnapshotPostcardLastResolution", 0) ; combo = floaterp->getChild("texture_size_combo"); combo->setCurrentByIndex(0) ; gSavedSettings.setS32("SnapshotTextureLastResolution", 0) ; combo = floaterp->getChild("local_size_combo"); combo->setCurrentByIndex(0) ; gSavedSettings.setS32("SnapshotLocalLastResolution", 0) ; LLSnapshotLivePreview* previewp = getPreviewView(floaterp); previewp->setSize(gViewerWindow->getWindowDisplayWidth(), gViewerWindow->getWindowDisplayHeight()); } bool use_freeze_frame = floaterp->childGetValue("freeze_frame_check").asBoolean(); // For now, auto-snapshot only works in freeze frame mode. // This can be changed in the future by taking the FreezeTime check // out of the onIdle() camera movement detection. JC floaterp->childSetEnabled("auto_snapshot_check", use_freeze_frame); if (use_freeze_frame) { // stop all mouse events at fullscreen preview layer floaterp->getParent()->setMouseOpaque(TRUE); // shrink to smaller layout floaterp->reshape(floaterp->getRect().getWidth(), floaterp->getUIWinHeightLong() + delta_height); // can see and interact with fullscreen preview now if (previewp) { previewp->setVisible(TRUE); previewp->setEnabled(TRUE); } //RN: freeze all avatars LLCharacter* avatarp; for (std::vector::iterator iter = LLCharacter::sInstances.begin(); iter != LLCharacter::sInstances.end(); ++iter) { avatarp = *iter; sInstance->impl.mAvatarPauseHandles.push_back(avatarp->requestPause()); } // freeze everything else gSavedSettings.setBOOL("FreezeTime", TRUE); if (LLToolMgr::getInstance()->getCurrentToolset() != gCameraToolset) { sInstance->impl.mLastToolset = LLToolMgr::getInstance()->getCurrentToolset(); LLToolMgr::getInstance()->setCurrentToolset(gCameraToolset); } } else // turning off freeze frame mode { // Force off auto-snapshot, see comment above about onIdle. JC gSavedSettings.setBOOL("AutoSnapshot", FALSE); floaterp->getParent()->setMouseOpaque(FALSE); floaterp->reshape(floaterp->getRect().getWidth(), floaterp->getUIWinHeightLong() + delta_height); if (previewp) { previewp->setVisible(FALSE); previewp->setEnabled(FALSE); } //RN: thaw all avatars sInstance->impl.mAvatarPauseHandles.clear(); // thaw everything else gSavedSettings.setBOOL("FreezeTime", FALSE); // restore last tool (e.g. pie menu, etc) if (sInstance->impl.mLastToolset) { LLToolMgr::getInstance()->setCurrentToolset(sInstance->impl.mLastToolset); } } } // static void LLFloaterSnapshot::Impl::updateControls(LLFloaterSnapshot* floater) { BOOL is_advance = gSavedSettings.getBOOL("AdvanceSnapshot") ; LLRadioGroup* snapshot_type_radio = floater->getChild("snapshot_type_radio"); snapshot_type_radio->setSelectedIndex(gSavedSettings.getS32("LastSnapshotType")); LLSnapshotLivePreview::ESnapshotType shot_type = getTypeIndex(floater); LLViewerWindow::ESnapshotType layer_type = getLayerType(floater); floater->childSetVisible("postcard_size_combo", FALSE); floater->childSetVisible("texture_size_combo", FALSE); floater->childSetVisible("local_size_combo", FALSE); LLComboBox* combo; combo = floater->getChild("postcard_size_combo"); if (combo) combo->selectNthItem(gSavedSettings.getS32("SnapshotPostcardLastResolution")); combo = floater->getChild("texture_size_combo"); if (combo) combo->selectNthItem(gSavedSettings.getS32("SnapshotTextureLastResolution")); combo = floater->getChild("local_size_combo"); if (combo) combo->selectNthItem(gSavedSettings.getS32("SnapshotLocalLastResolution")); floater->childSetVisible("upload_btn", FALSE); floater->childSetVisible("send_btn", FALSE); floater->childSetVisible("save_btn", FALSE); floater->childSetEnabled("keep_aspect_check", FALSE) ; switch(shot_type) { case LLSnapshotLivePreview::SNAPSHOT_POSTCARD: layer_type = LLViewerWindow::SNAPSHOT_TYPE_COLOR; floater->childSetValue("layer_types", "colors"); floater->childSetEnabled("layer_types", FALSE); if(is_advance) { floater->childSetEnabled("image_quality_slider", TRUE); setResolution(floater, "postcard_size_combo"); if(!sAspectRatioCheckOff) { floater->childSetEnabled("keep_aspect_check", TRUE) ; } } floater->childSetVisible("send_btn", TRUE); break; case LLSnapshotLivePreview::SNAPSHOT_TEXTURE: layer_type = LLViewerWindow::SNAPSHOT_TYPE_COLOR; floater->childSetValue("layer_types", "colors"); floater->childSetEnabled("layer_types", FALSE); floater->childSetEnabled("image_quality_slider", FALSE); if(is_advance) { setResolution(floater, "texture_size_combo"); } floater->childSetVisible("upload_btn", TRUE); break; case LLSnapshotLivePreview::SNAPSHOT_BITMAP: floater->childSetEnabled("layer_types", TRUE); floater->childSetEnabled("image_quality_slider", FALSE); if(is_advance) { setResolution(floater, "local_size_combo"); if(!sAspectRatioCheckOff) { floater->childSetEnabled("keep_aspect_check", TRUE) ; } } floater->childSetVisible("save_btn", TRUE); break; default: break; } if(is_advance) { floater->childSetVisible("type_label2", TRUE) ; floater->childSetVisible("layer_types", TRUE) ; floater->childSetVisible("layer_type_label", TRUE) ; floater->childSetVisible("snapshot_width", TRUE) ; floater->childSetVisible("snapshot_height", TRUE) ; floater->childSetVisible("keep_aspect_check", TRUE) ; floater->childSetVisible("ui_check", TRUE) ; floater->childSetVisible("hud_check", TRUE) ; floater->childSetVisible("keep_open_check", TRUE) ; floater->childSetVisible("freeze_frame_check", TRUE) ; floater->childSetVisible("auto_snapshot_check", TRUE) ; floater->childSetVisible("image_quality_slider", TRUE); floater->childSetVisible("more_btn", FALSE); floater->childSetVisible("less_btn", TRUE); } else { floater->childSetVisible("type_label2", FALSE) ; floater->childSetVisible("layer_types", FALSE) ; floater->childSetVisible("layer_type_label", FALSE) ; floater->childSetVisible("snapshot_width", FALSE) ; floater->childSetVisible("snapshot_height", FALSE) ; floater->childSetVisible("keep_aspect_check", FALSE) ; floater->childSetVisible("ui_check", FALSE) ; floater->childSetVisible("hud_check", FALSE) ; floater->childSetVisible("keep_open_check", FALSE) ; floater->childSetVisible("freeze_frame_check", FALSE) ; floater->childSetVisible("auto_snapshot_check", FALSE) ; floater->childSetVisible("image_quality_slider", FALSE); floater->childSetVisible("more_btn", TRUE); floater->childSetVisible("less_btn", FALSE); } LLSnapshotLivePreview* previewp = getPreviewView(floater); if (previewp) { previewp->setSnapshotType(shot_type); previewp->setSnapshotBufferType(layer_type); } } // static void LLFloaterSnapshot::Impl::checkAutoSnapshot(LLSnapshotLivePreview* previewp, BOOL update_thumbnail) { if (previewp) { previewp->updateSnapshot(gSavedSettings.getBOOL("AutoSnapshot"), update_thumbnail); } } // static void LLFloaterSnapshot::Impl::onClickDiscard(void* data) { LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { view->close(); } } // static void LLFloaterSnapshot::Impl::onClickKeep(void* data) { LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; LLSnapshotLivePreview* previewp = getPreviewView(view); if (previewp) { BOOL succeeded = TRUE; // Only used for saveLocal for now if (previewp->getSnapshotType() == LLSnapshotLivePreview::SNAPSHOT_POSTCARD) { LLFloaterPostcard* floater = previewp->savePostcard(); // if still in snapshot mode, put postcard floater in snapshot floaterview // and link it to snapshot floater if (!gSavedSettings.getBOOL("CloseSnapshotOnKeep")) { gFloaterView->removeChild(floater); gSnapshotFloaterView->addChild(floater); view->addDependentFloater(floater, FALSE); } } else if (previewp->getSnapshotType() == LLSnapshotLivePreview::SNAPSHOT_TEXTURE) { previewp->saveTexture(); } else { succeeded = previewp->saveLocal(); } if (gSavedSettings.getBOOL("CloseSnapshotOnKeep")) { view->close(); } else { checkAutoSnapshot(previewp); } } } // static void LLFloaterSnapshot::Impl::onClickNewSnapshot(void* data) { LLSnapshotLivePreview* previewp = getPreviewView((LLFloaterSnapshot *)data); LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (previewp && view) { previewp->updateSnapshot(TRUE); } } // static void LLFloaterSnapshot::Impl::onClickAutoSnap(LLUICtrl *ctrl, void* data) { LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl; gSavedSettings.setBOOL( "AutoSnapshot", check->get() ); LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { checkAutoSnapshot(getPreviewView(view)); } } void LLFloaterSnapshot::Impl::onClickMore(void* data) { gSavedSettings.setBOOL( "AdvanceSnapshot", TRUE ); LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { view->translate( 0, view->getUIWinHeightShort() - view->getUIWinHeightLong() ); view->reshape(view->getRect().getWidth(), view->getUIWinHeightLong()); updateControls(view) ; updateLayout(view) ; } } void LLFloaterSnapshot::Impl::onClickLess(void* data) { gSavedSettings.setBOOL( "AdvanceSnapshot", FALSE ); LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { view->translate( 0, view->getUIWinHeightLong() - view->getUIWinHeightShort() ); view->reshape(view->getRect().getWidth(), view->getUIWinHeightShort()); updateControls(view) ; updateLayout(view) ; if(getPreviewView(view)) { getPreviewView(view)->setThumbnailImageSize() ; } } } // static void LLFloaterSnapshot::Impl::onClickUICheck(LLUICtrl *ctrl, void* data) { LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl; gSavedSettings.setBOOL( "RenderUIInSnapshot", check->get() ); LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { checkAutoSnapshot(getPreviewView(view), TRUE); } } // static void LLFloaterSnapshot::Impl::onClickHUDCheck(LLUICtrl *ctrl, void* data) { LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl; gSavedSettings.setBOOL( "RenderHUDInSnapshot", check->get() ); LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { checkAutoSnapshot(getPreviewView(view), TRUE); } } // static void LLFloaterSnapshot::Impl::onClickKeepOpenCheck(LLUICtrl* ctrl, void* data) { LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl; gSavedSettings.setBOOL( "CloseSnapshotOnKeep", !check->get() ); } // static void LLFloaterSnapshot::Impl::onClickKeepAspectCheck(LLUICtrl* ctrl, void* data) { LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl; gSavedSettings.setBOOL( "KeepAspectForSnapshot", check->get() ); LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { LLSnapshotLivePreview* previewp = getPreviewView(view) ; if(previewp) { previewp->mKeepAspectRatio = gSavedSettings.getBOOL("KeepAspectForSnapshot") ; S32 w, h ; previewp->getSize(w, h) ; if(checkImageSize(previewp, w, h, TRUE, previewp->getMaxImageSize())) { resetSnapshotSizeOnUI(view, w, h) ; } previewp->setSize(w, h) ; checkAutoSnapshot(previewp, TRUE); } } } // static void LLFloaterSnapshot::Impl::onCommitQuality(LLUICtrl* ctrl, void* data) { LLSliderCtrl* slider = (LLSliderCtrl*)ctrl; S32 quality_val = llfloor((F32)slider->getValue().asReal()); LLSnapshotLivePreview* previewp = getPreviewView((LLFloaterSnapshot *)data); if (previewp) { previewp->setSnapshotQuality(quality_val); } checkAutoSnapshot(previewp, TRUE); } // static void LLFloaterSnapshot::Impl::onCommitFreezeFrame(LLUICtrl* ctrl, void* data) { LLCheckBoxCtrl* check_box = (LLCheckBoxCtrl*)ctrl; LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (!view || !check_box) { return; } gSavedSettings.setBOOL("UseFreezeFrame", check_box->get()); updateLayout(view); } // static void LLFloaterSnapshot::Impl::checkAspectRatio(LLFloaterSnapshot *view, S32 index) { LLSnapshotLivePreview *previewp = getPreviewView(view) ; if(LLSnapshotLivePreview::SNAPSHOT_TEXTURE == getTypeIndex(view)) { previewp->mKeepAspectRatio = FALSE ; return ; } if(!index) //current window size { sAspectRatioCheckOff = TRUE ; view->childSetEnabled("keep_aspect_check", FALSE) ; if(previewp) { previewp->mKeepAspectRatio = TRUE ; } } else if(-1 == index) //custom { sAspectRatioCheckOff = FALSE ; if(LLSnapshotLivePreview::SNAPSHOT_TEXTURE != gSavedSettings.getS32("LastSnapshotType")) { view->childSetEnabled("keep_aspect_check", TRUE) ; if(previewp) { previewp->mKeepAspectRatio = gSavedSettings.getBOOL("KeepAspectForSnapshot") ; } } } else { sAspectRatioCheckOff = TRUE ; view->childSetEnabled("keep_aspect_check", FALSE) ; if(previewp) { previewp->mKeepAspectRatio = FALSE ; } } return ; } // static void LLFloaterSnapshot::Impl::onCommitResolution(LLUICtrl* ctrl, void* data) { LLComboBox* combobox = (LLComboBox*)ctrl; LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (!view || !combobox) { return; } // save off all selected resolution values LLComboBox* combo; combo = view->getChild("postcard_size_combo"); gSavedSettings.setS32("SnapshotPostcardLastResolution", combo->getCurrentIndex()); combo = view->getChild("texture_size_combo"); gSavedSettings.setS32("SnapshotTextureLastResolution", combo->getCurrentIndex()); combo = view->getChild("local_size_combo"); gSavedSettings.setS32("SnapshotLocalLastResolution", combo->getCurrentIndex()); std::string sdstring = combobox->getSelectedValue(); LLSD sdres; std::stringstream sstream(sdstring); LLSDSerialize::fromNotation(sdres, sstream, sdstring.size()); S32 width = sdres[0]; S32 height = sdres[1]; LLSnapshotLivePreview* previewp = getPreviewView(view); if (previewp && combobox->getCurrentIndex() >= 0) { if (width == 0 || height == 0) { previewp->setSize(gViewerWindow->getWindowDisplayWidth(), gViewerWindow->getWindowDisplayHeight()); } else if (width == -1 || height == -1) { // load last custom value previewp->setSize(gSavedSettings.getS32("LastSnapshotWidth"), gSavedSettings.getS32("LastSnapshotHeight")); } else { previewp->setSize(width, height); } checkAspectRatio(view, width) ; previewp->getSize(width, height); if(checkImageSize(previewp, width, height, TRUE, previewp->getMaxImageSize())) { resetSnapshotSizeOnUI(view, width, height) ; } previewp->setSize(width, height); view->childSetValue("snapshot_width", width); view->childSetValue("snapshot_height", height); // hide old preview as the aspect ratio could be wrong checkAutoSnapshot(previewp, FALSE); } } // static void LLFloaterSnapshot::Impl::onCommitLayerTypes(LLUICtrl* ctrl, void*data) { LLComboBox* combobox = (LLComboBox*)ctrl; LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { LLSnapshotLivePreview* previewp = getPreviewView(view); if (previewp) { previewp->setSnapshotBufferType((LLViewerWindow::ESnapshotType)combobox->getCurrentIndex()); } checkAutoSnapshot(previewp, TRUE); } } //static void LLFloaterSnapshot::Impl::onCommitSnapshotType(LLUICtrl* ctrl, void* data) { LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { gSavedSettings.setS32("LastSnapshotType", getTypeIndex(view)); getPreviewView(view)->updateSnapshot(TRUE); updateControls(view); } } // static void LLFloaterSnapshot::Impl::comboSetCustom(LLFloaterSnapshot* floater, const std::string& comboname) { LLComboBox* combo = floater->getChild(comboname); if (combo) { combo->setCurrentByIndex(combo->getItemCount() - 1); checkAspectRatio(floater, -1);//combo->getCurrentIndex()) ; } } //static BOOL LLFloaterSnapshot::Impl::checkImageSize(LLSnapshotLivePreview* previewp, S32& width, S32& height, BOOL isWidthChanged, S32 max_value) { S32 w = width ; S32 h = height ; //if texture, ignore aspect ratio setting, round image size to power of 2. if(LLSnapshotLivePreview::SNAPSHOT_TEXTURE == gSavedSettings.getS32("LastSnapshotType")) { if(width > max_value) { width = max_value ; } if(height > max_value) { height = max_value ; } //round to nearest power of 2 width = get_nearest_power_two(width, MAX_TEXTURE_SIZE) ; height = get_nearest_power_two(height, MAX_TEXTURE_SIZE) ; } else if(previewp && previewp->mKeepAspectRatio) { if(gViewerWindow->getWindowDisplayWidth() < 1 || gViewerWindow->getWindowDisplayHeight() < 1) { return FALSE ; } //aspect ratio of the current window F32 aspect_ratio = (F32)gViewerWindow->getWindowDisplayWidth() / gViewerWindow->getWindowDisplayHeight() ; //change another value proportionally if(isWidthChanged) { height = (S32)(width / aspect_ratio) ; } else { width = (S32)(height * aspect_ratio) ; } //bound w/h by the max_value if(width > max_value || height > max_value) { if(width > height) { width = max_value ; height = (S32)(width / aspect_ratio) ; } else { height = max_value ; width = (S32)(height * aspect_ratio) ; } } } else { } return (w != width || h != height) ; } //static void LLFloaterSnapshot::Impl::resetSnapshotSizeOnUI(LLFloaterSnapshot *view, S32 width, S32 height) { LLSpinCtrl *sctrl = view->getChild("snapshot_width") ; if(sctrl) { sctrl->forceSetValue(width) ; } sctrl = view->getChild("snapshot_height") ; if(sctrl) { sctrl->forceSetValue(height) ; } gSavedSettings.setS32("LastSnapshotWidth", width); gSavedSettings.setS32("LastSnapshotHeight", height); } //static void LLFloaterSnapshot::Impl::onCommitCustomResolution(LLUICtrl *ctrl, void* data) { LLFloaterSnapshot *view = (LLFloaterSnapshot *)data; if (view) { S32 w = llfloor((F32)view->childGetValue("snapshot_width").asReal()); S32 h = llfloor((F32)view->childGetValue("snapshot_height").asReal()); gSavedSettings.setS32("LastSnapshotWidth", w); gSavedSettings.setS32("LastSnapshotHeight", h); LLSnapshotLivePreview* previewp = getPreviewView(view); if (previewp) { S32 curw,curh; previewp->getSize(curw, curh); if (w != curw || h != curh) { BOOL update_ = FALSE ; //if to upload a snapshot, process spinner input in a special way. if(LLSnapshotLivePreview::SNAPSHOT_TEXTURE == gSavedSettings.getS32("LastSnapshotType")) { S32 spinner_increment = (S32)((LLSpinCtrl*)ctrl)->getIncrement() ; S32 dw = w - curw ; S32 dh = h - curh ; dw = (dw == spinner_increment) ? 1 : ((dw == -spinner_increment) ? -1 : 0) ; dh = (dh == spinner_increment) ? 1 : ((dh == -spinner_increment) ? -1 : 0) ; if(dw) { w = (dw > 0) ? curw << dw : curw >> -dw ; update_ = TRUE ; } if(dh) { h = (dh > 0) ? curh << dh : curh >> -dh ; update_ = TRUE ; } } previewp->setMaxImageSize((S32)((LLSpinCtrl *)ctrl)->getMaxValue()) ; if(checkImageSize(previewp, w, h, w != curw, previewp->getMaxImageSize()) || update_) { resetSnapshotSizeOnUI(view, w, h) ; } previewp->setSize(w,h); checkAutoSnapshot(previewp, FALSE); comboSetCustom(view, "postcard_size_combo"); comboSetCustom(view, "texture_size_combo"); comboSetCustom(view, "local_size_combo"); } } } } ///---------------------------------------------------------------------------- /// Class LLFloaterSnapshot ///---------------------------------------------------------------------------- // Default constructor LLFloaterSnapshot::LLFloaterSnapshot() : LLFloater(std::string("Snapshot Floater")), impl (*(new Impl)) { } // Destroys the object LLFloaterSnapshot::~LLFloaterSnapshot() { if (sInstance == this) { LLView::deleteViewByHandle(Impl::sPreviewHandle); Impl::sPreviewHandle = LLHandle(); sInstance = NULL; } //unfreeze everything else gSavedSettings.setBOOL("FreezeTime", FALSE); if (impl.mLastToolset) { LLToolMgr::getInstance()->setCurrentToolset(impl.mLastToolset); } delete &impl; } BOOL LLFloaterSnapshot::postBuild() { childSetCommitCallback("snapshot_type_radio", Impl::onCommitSnapshotType, this); childSetAction("new_snapshot_btn", Impl::onClickNewSnapshot, this); childSetValue("auto_snapshot_check", gSavedSettings.getBOOL("AutoSnapshot")); childSetCommitCallback("auto_snapshot_check", Impl::onClickAutoSnap, this); //childSetValue("advance_snapshot_check", gSavedSettings.getBOOL("AdvanceSnapshot")); //childSetCommitCallback("advance_snapshot_check", Impl::onClickAdvanceSnap, this); childSetAction("more_btn", Impl::onClickMore, this); childSetAction("less_btn", Impl::onClickLess, this); childSetAction("upload_btn", Impl::onClickKeep, this); childSetAction("send_btn", Impl::onClickKeep, this); childSetAction("save_btn", Impl::onClickKeep, this); childSetAction("discard_btn", Impl::onClickDiscard, this); childSetCommitCallback("image_quality_slider", Impl::onCommitQuality, this); childSetValue("image_quality_slider", gSavedSettings.getS32("SnapshotQuality")); childSetCommitCallback("snapshot_width", Impl::onCommitCustomResolution, this); childSetCommitCallback("snapshot_height", Impl::onCommitCustomResolution, this); childSetCommitCallback("ui_check", Impl::onClickUICheck, this); childSetCommitCallback("hud_check", Impl::onClickHUDCheck, this); childSetValue("hud_check", gSavedSettings.getBOOL("RenderHUDInSnapshot")); childSetCommitCallback("keep_open_check", Impl::onClickKeepOpenCheck, this); childSetValue("keep_open_check", !gSavedSettings.getBOOL("CloseSnapshotOnKeep")); childSetCommitCallback("keep_aspect_check", Impl::onClickKeepAspectCheck, this); childSetValue("keep_aspect_check", gSavedSettings.getBOOL("KeepAspectForSnapshot")); childSetCommitCallback("layer_types", Impl::onCommitLayerTypes, this); childSetValue("layer_types", "colors"); childSetEnabled("layer_types", FALSE); childSetValue("snapshot_width", gSavedSettings.getS32("LastSnapshotWidth")); childSetValue("snapshot_height", gSavedSettings.getS32("LastSnapshotHeight")); childSetValue("freeze_frame_check", gSavedSettings.getBOOL("UseFreezeFrame")); childSetCommitCallback("freeze_frame_check", Impl::onCommitFreezeFrame, this); childSetCommitCallback("postcard_size_combo", Impl::onCommitResolution, this); childSetCommitCallback("texture_size_combo", Impl::onCommitResolution, this); childSetCommitCallback("local_size_combo", Impl::onCommitResolution, this); // create preview window LLRect full_screen_rect = sInstance->getRootView()->getRect(); LLSnapshotLivePreview* previewp = new LLSnapshotLivePreview(full_screen_rect); sInstance->getRootView()->removeChild(gSnapshotFloaterView); // make sure preview is below snapshot floater sInstance->getRootView()->addChild(previewp); sInstance->getRootView()->addChild(gSnapshotFloaterView); Impl::sPreviewHandle = previewp->getHandle(); impl.updateControls(this); return TRUE; } void LLFloaterSnapshot::draw() { LLSnapshotLivePreview* previewp = impl.getPreviewView(this); if (previewp && (previewp->isSnapshotActive() || previewp->getThumbnailLock())) { // don't render snapshot window in snapshot, even if "show ui" is turned on return; } if(!isMinimized()) { if (previewp && previewp->getDataSize() > 0) { LLLocale locale(LLLocale::USER_LOCALE); std::string bytes_string; if (previewp->getSnapshotType() == LLSnapshotLivePreview::SNAPSHOT_POSTCARD && previewp->getDataSize() > MAX_POSTCARD_DATASIZE) { childSetColor("file_size_label", LLColor4::red); childSetEnabled("send_btn", FALSE); } else { childSetColor("file_size_label", gColors.getColor( "LabelTextColor" )); childSetEnabled("send_btn", previewp->getSnapshotUpToDate()); } if (previewp->getSnapshotUpToDate()) { std::string bytes_string; LLResMgr::getInstance()->getIntegerString(bytes_string, (previewp->getDataSize()) >> 10 ); childSetTextArg("file_size_label", "[SIZE]", bytes_string); } else { childSetTextArg("file_size_label", "[SIZE]", getString("unknown")); childSetColor("file_size_label", gColors.getColor( "LabelTextColor" )); } childSetEnabled("upload_btn", previewp->getSnapshotUpToDate()); childSetEnabled("save_btn", previewp->getSnapshotUpToDate()); } else { childSetTextArg("file_size_label", "[SIZE]", std::string("???")); childSetEnabled("upload_btn", FALSE); childSetEnabled("send_btn", FALSE); childSetEnabled("save_btn", FALSE); } BOOL ui_in_snapshot = gSavedSettings.getBOOL("RenderUIInSnapshot"); childSetValue("ui_check", ui_in_snapshot); childSetToolTip("ui_check", std::string("If selected shows the UI in the snapshot")); } LLFloater::draw(); // draw snapshot thumbnail if not in fullscreen preview mode /*if (previewp && previewp->getCurrentImage() && previewp->getSnapshotUpToDate()) { F32 aspect = previewp->getImageAspect(); // UI size for thumbnail S32 max_width = getRect().getWidth() - 20; S32 max_height = 90; S32 img_render_width = 0; S32 img_render_height = 0; if (aspect > max_width / max_height) { // image too wide, shrink to width img_render_width = max_width; img_render_height = llround((F32)max_width / aspect); } else { // image too tall, shrink to height img_render_height = max_height; img_render_width = llround((F32)max_height * aspect); } S32 image_width, image_height; previewp->getSize(image_width, image_height); glMatrixMode(GL_TEXTURE); glPushMatrix(); { // handle case where image is only a portion of image buffer if (!previewp->isImageScaled()) { glScalef(llmin(1.f, (F32)image_width / (F32)previewp->getCurrentImage()->getWidth()), llmin(1.f, (F32)image_height / (F32)previewp->getCurrentImage()->getHeight()), 1.f); } glMatrixMode(GL_MODELVIEW); gl_draw_scaled_image((getRect().getWidth() - img_render_width) / 2, getRect().getHeight() - 205 + (max_height - img_render_height) / 2, img_render_width, img_render_height, previewp->getCurrentImage(), LLColor4::white); } glMatrixMode(GL_TEXTURE); glPopMatrix(); glMatrixMode(GL_MODELVIEW); }*/ if (previewp) { if(previewp->getThumbnailImage()) { S32 offset_x = (getRect().getWidth() - previewp->getThumbnailWidth()) / 2 ; S32 offset_y = getRect().getHeight() - 205 + (90 - previewp->getThumbnailHeight()) / 2 ; glMatrixMode(GL_MODELVIEW); gl_draw_scaled_image(offset_x, offset_y, previewp->getThumbnailWidth(), previewp->getThumbnailHeight(), previewp->getThumbnailImage(), LLColor4::white); previewp->drawPreviewRect(offset_x, offset_y) ; } } } void LLFloaterSnapshot::onClose(bool app_quitting) { gSnapshotFloaterView->setEnabled(FALSE); destroy(); } // static void LLFloaterSnapshot::show(void*) { if (!sInstance) { sInstance = new LLFloaterSnapshot(); LLUICtrlFactory::getInstance()->buildFloater(sInstance, "floater_snapshot.xml", NULL, FALSE); //move snapshot floater to special purpose snapshotfloaterview gFloaterView->removeChild(sInstance); gSnapshotFloaterView->addChild(sInstance); sInstance->impl.updateLayout(sInstance); } sInstance->open(); /* Flawfinder: ignore */ sInstance->focusFirstItem(FALSE); gSnapshotFloaterView->setEnabled(TRUE); gSnapshotFloaterView->adjustToFitScreen(sInstance, FALSE); } void LLFloaterSnapshot::hide(void*) { if (sInstance && !sInstance->isDead()) { sInstance->close(); } } //static void LLFloaterSnapshot::update() { for (std::set::iterator iter = LLSnapshotLivePreview::sList.begin(); iter != LLSnapshotLivePreview::sList.end(); ++iter) { LLSnapshotLivePreview::onIdle(*iter); } } //============================================================================ LLSnapshotFloaterView::LLSnapshotFloaterView( const std::string& name, const LLRect& rect ) : LLFloaterView(name, rect) { setMouseOpaque(TRUE); setEnabled(FALSE); } LLSnapshotFloaterView::~LLSnapshotFloaterView() { } BOOL LLSnapshotFloaterView::handleKey(KEY key, MASK mask, BOOL called_from_parent) { // use default handler when not in freeze-frame mode if(!gSavedSettings.getBOOL("FreezeTime")) { return LLFloaterView::handleKey(key, mask, called_from_parent); } if (called_from_parent) { // pass all keystrokes down LLFloaterView::handleKey(key, mask, called_from_parent); } else { // bounce keystrokes back down LLFloaterView::handleKey(key, mask, TRUE); } return TRUE; } BOOL LLSnapshotFloaterView::handleMouseDown(S32 x, S32 y, MASK mask) { // use default handler when not in freeze-frame mode if(!gSavedSettings.getBOOL("FreezeTime")) { return LLFloaterView::handleMouseDown(x, y, mask); } // give floater a change to handle mouse, else camera tool if (childrenHandleMouseDown(x, y, mask) == NULL) { LLToolMgr::getInstance()->getCurrentTool()->handleMouseDown( x, y, mask ); } return TRUE; } BOOL LLSnapshotFloaterView::handleMouseUp(S32 x, S32 y, MASK mask) { // use default handler when not in freeze-frame mode if(!gSavedSettings.getBOOL("FreezeTime")) { return LLFloaterView::handleMouseUp(x, y, mask); } // give floater a change to handle mouse, else camera tool if (childrenHandleMouseUp(x, y, mask) == NULL) { LLToolMgr::getInstance()->getCurrentTool()->handleMouseUp( x, y, mask ); } return TRUE; } BOOL LLSnapshotFloaterView::handleHover(S32 x, S32 y, MASK mask) { // use default handler when not in freeze-frame mode if(!gSavedSettings.getBOOL("FreezeTime")) { return LLFloaterView::handleHover(x, y, mask); } // give floater a change to handle mouse, else camera tool if (childrenHandleHover(x, y, mask) == NULL) { LLToolMgr::getInstance()->getCurrentTool()->handleHover( x, y, mask ); } return TRUE; }