Second Life Viewer: llfloaterimagepreview.cpp Source File

00001 
00032 #include "llviewerprecompiledheaders.h"
00033 
00034 #include "llfloaterimagepreview.h"
00035 
00036 #include "llimagebmp.h"
00037 #include "llimagetga.h"
00038 #include "llimagejpeg.h"
00039 #include "llimagepng.h"
00040 
00041 #include "llagent.h"
00042 #include "llbutton.h"
00043 #include "llcombobox.h"
00044 #include "lldrawable.h"
00045 #include "lldrawpoolavatar.h"
00046 #include "llface.h"
00047 #include "lltextbox.h"
00048 #include "lltoolmgr.h"
00049 #include "llui.h"
00050 #include "llviewercamera.h"
00051 #include "llviewerwindow.h"
00052 #include "llvoavatar.h"
00053 #include "pipeline.h"
00054 #include "viewer.h"
00055 #include "llvieweruictrlfactory.h"
00056 #include "llviewerimagelist.h"
00057 
00058 //static
00059 S32 LLFloaterImagePreview::sUploadAmount = 10;
00060 
00061 const S32 PREVIEW_BORDER_WIDTH = 2;
00062 const S32 PREVIEW_RESIZE_HANDLE_SIZE = S32(RESIZE_HANDLE_WIDTH * OO_SQRT2) + PREVIEW_BORDER_WIDTH;
00063 const S32 PREVIEW_HPAD = PREVIEW_RESIZE_HANDLE_SIZE;
00064 const S32 PREF_BUTTON_HEIGHT = 16 + 7 + 16;
00065 const S32 PREVIEW_TEXTURE_HEIGHT = 300;
00066 
00067 
00068 //-----------------------------------------------------------------------------
00069 // LLFloaterImagePreview()
00070 //-----------------------------------------------------------------------------
00071 LLFloaterImagePreview::LLFloaterImagePreview(const char* filename) : 
00072         LLFloaterNameDesc(filename)
00073 {
00074         mLastMouseX = 0;
00075         mLastMouseY = 0;
00076         mGLName = 0;
00077         loadImage(mFilenameAndPath.c_str());
00078 }
00079 
00080 //-----------------------------------------------------------------------------
00081 // postBuild()
00082 //-----------------------------------------------------------------------------
00083 BOOL LLFloaterImagePreview::postBuild()
00084 {
00085         if (!LLFloaterNameDesc::postBuild())
00086         {
00087                 return FALSE;
00088         }
00089 
00090         childSetLabelArg("ok_btn", "[AMOUNT]", llformat("%d",sUploadAmount));
00091 
00092         LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
00093         if (iface)
00094         {
00095                 iface->selectFirstItem();
00096         }
00097         childSetCommitCallback("clothing_type_combo", onPreviewTypeCommit, this);
00098 
00099         mPreviewRect.set(PREVIEW_HPAD, 
00100                 PREVIEW_TEXTURE_HEIGHT,
00101                 getRect().getWidth() - PREVIEW_HPAD, 
00102                 PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
00103         mPreviewImageRect.set(0.f, 1.f, 1.f, 0.f);
00104 
00105         childHide("bad_image_text");
00106 
00107         if (mRawImagep.notNull())
00108         {
00109                 mAvatarPreview = new LLImagePreviewAvatar(256, 256);
00110                 mAvatarPreview->setPreviewTarget("mPelvis", "mUpperBodyMesh0", mRawImagep, 2.f, FALSE);
00111 
00112                 mSculptedPreview = new LLImagePreviewSculpted(256, 256);
00113                 mSculptedPreview->setPreviewTarget(mRawImagep, 2.0f);
00114 
00115                 if ((mRawImagep->getWidth() <= LL_IMAGE_REZ_LOSSLESS_CUTOFF) &&
00116                         (mRawImagep->getHeight() <= LL_IMAGE_REZ_LOSSLESS_CUTOFF))
00117                         childEnable("lossless_check");
00118         }
00119         else
00120         {
00121                 mAvatarPreview = NULL;
00122                 mSculptedPreview = NULL;
00123                 childShow("bad_image_text");
00124                 childDisable("clothing_type_combo");
00125                 childDisable("ok_btn");
00126         }
00127 
00128         return TRUE;
00129 }
00130 
00131 //-----------------------------------------------------------------------------
00132 // LLFloaterImagePreview()
00133 //-----------------------------------------------------------------------------
00134 LLFloaterImagePreview::~LLFloaterImagePreview()
00135 {
00136         mRawImagep = NULL;
00137         delete mAvatarPreview;
00138         delete mSculptedPreview;
00139         
00140         if (mGLName)
00141         {
00142                 glDeleteTextures(1, &mGLName );
00143         }
00144 }
00145 
00146 //static 
00147 //-----------------------------------------------------------------------------
00148 // onPreviewTypeCommit()
00149 //-----------------------------------------------------------------------------
00150 void    LLFloaterImagePreview::onPreviewTypeCommit(LLUICtrl* ctrl, void* userdata)
00151 {
00152         LLFloaterImagePreview *fp =(LLFloaterImagePreview *)userdata;
00153         
00154         if (!fp->mAvatarPreview || !fp->mSculptedPreview)
00155         {
00156                 return;
00157         }
00158 
00159         S32 which_mode = 0;
00160 
00161         LLCtrlSelectionInterface* iface = fp->childGetSelectionInterface("clothing_type_combo");
00162         if (iface)
00163         {
00164                 which_mode = iface->getFirstSelectedIndex();
00165         }
00166 
00167         switch(which_mode)
00168         {
00169         case 0:
00170                 break;
00171         case 1:
00172                 fp->mAvatarPreview->setPreviewTarget("mSkull", "mHairMesh0", fp->mRawImagep, 0.4f, FALSE);
00173                 break;
00174         case 2:
00175                 fp->mAvatarPreview->setPreviewTarget("mSkull", "mHeadMesh0", fp->mRawImagep, 0.4f, FALSE);
00176                 break;
00177         case 3:
00178                 fp->mAvatarPreview->setPreviewTarget("mChest", "mUpperBodyMesh0", fp->mRawImagep, 1.0f, FALSE);
00179                 break;
00180         case 4:
00181                 fp->mAvatarPreview->setPreviewTarget("mKneeLeft", "mLowerBodyMesh0", fp->mRawImagep, 1.2f, FALSE);
00182                 break;
00183         case 5:
00184                 fp->mAvatarPreview->setPreviewTarget("mSkull", "mHeadMesh0", fp->mRawImagep, 0.4f, TRUE);
00185                 break;
00186         case 6:
00187                 fp->mAvatarPreview->setPreviewTarget("mChest", "mUpperBodyMesh0", fp->mRawImagep, 1.2f, TRUE);
00188                 break;
00189         case 7:
00190                 fp->mAvatarPreview->setPreviewTarget("mKneeLeft", "mLowerBodyMesh0", fp->mRawImagep, 1.2f, TRUE);
00191                 break;
00192         case 8:
00193                 fp->mAvatarPreview->setPreviewTarget("mKneeLeft", "mSkirtMesh0", fp->mRawImagep, 1.3f, FALSE);
00194                 break;
00195         case 9:
00196                 fp->mSculptedPreview->setPreviewTarget(fp->mRawImagep, 2.0f);
00197                 break;
00198         default:
00199                 break;
00200         }
00201         
00202         fp->mAvatarPreview->refresh();
00203         fp->mSculptedPreview->refresh();
00204 }
00205 
00206 //-----------------------------------------------------------------------------
00207 // draw()
00208 //-----------------------------------------------------------------------------
00209 void LLFloaterImagePreview::draw()
00210 {
00211         LLFloater::draw();
00212         LLRect r = getRect();
00213 
00214         if (mRawImagep.notNull())
00215         {
00216                 LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
00217                 U32 selected = 0;
00218                 if (iface)
00219                         selected = iface->getFirstSelectedIndex();
00220                 
00221                 if (selected <= 0)
00222                 {
00223                         gl_rect_2d_checkerboard(mPreviewRect);
00224                         LLGLDisable gls_alpha(GL_ALPHA_TEST);
00225 
00226                         GLenum format_options[4] = { GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA };
00227                         GLenum format = format_options[mRawImagep->getComponents()-1];
00228 
00229                         GLenum internal_format_options[4] = { GL_LUMINANCE8, GL_LUMINANCE8_ALPHA8, GL_RGB8, GL_RGBA8 };
00230                         GLenum internal_format = internal_format_options[mRawImagep->getComponents()-1];
00231                 
00232                         if (mGLName)
00233                         {
00234                                 LLImageGL::bindExternalTexture( mGLName, 0, GL_TEXTURE_2D ); 
00235                         }
00236                         else
00237                         {
00238                                 glGenTextures(1, &mGLName );
00239                                 stop_glerror();
00240 
00241                                 LLImageGL::bindExternalTexture( mGLName, 0, GL_TEXTURE_2D ); 
00242                                 stop_glerror();
00243 
00244                                 glTexImage2D(
00245                                         GL_TEXTURE_2D, 0, internal_format, 
00246                                         mRawImagep->getWidth(), mRawImagep->getHeight(),
00247                                         0, format, GL_UNSIGNED_BYTE, mRawImagep->getData());
00248                                 stop_glerror();
00249 
00250                                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
00251                                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
00252                                 
00253                                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
00254                                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
00255                                 if (mAvatarPreview)
00256                                 {
00257                                         mAvatarPreview->setTexture(mGLName);
00258                                         mSculptedPreview->setTexture(mGLName);
00259                                 }
00260                         }
00261 
00262                         glColor3f(1.f, 1.f, 1.f);
00263                         glBegin( GL_QUADS );
00264                         {
00265                                 glTexCoord2f(mPreviewImageRect.mLeft, mPreviewImageRect.mTop);
00266                                 glVertex2i(PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
00267                                 glTexCoord2f(mPreviewImageRect.mLeft, mPreviewImageRect.mBottom);
00268                                 glVertex2i(PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
00269                                 glTexCoord2f(mPreviewImageRect.mRight, mPreviewImageRect.mBottom);
00270                                 glVertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
00271                                 glTexCoord2f(mPreviewImageRect.mRight, mPreviewImageRect.mTop);
00272                                 glVertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
00273                         }
00274                         glEnd();
00275 
00276                         LLImageGL::unbindTexture(0, GL_TEXTURE_2D);
00277 
00278                         stop_glerror();
00279                 }
00280                 else
00281                 {
00282                         if ((mAvatarPreview) && (mSculptedPreview))
00283                         {
00284                                 glColor3f(1.f, 1.f, 1.f);
00285 
00286                                 if (selected == 9)
00287                                         mSculptedPreview->bindTexture();
00288                                 else
00289                                         mAvatarPreview->bindTexture();
00290 
00291                                 glBegin( GL_QUADS );
00292                                 {
00293                                         glTexCoord2f(0.f, 1.f);
00294                                         glVertex2i(PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
00295                                         glTexCoord2f(0.f, 0.f);
00296                                         glVertex2i(PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
00297                                         glTexCoord2f(1.f, 0.f);
00298                                         glVertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
00299                                         glTexCoord2f(1.f, 1.f);
00300                                         glVertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
00301                                 }
00302                                 glEnd();
00303 
00304                                 if (selected == 9)
00305                                         mSculptedPreview->unbindTexture();
00306                                 else
00307                                         mAvatarPreview->unbindTexture();
00308                         }
00309                 }
00310         }
00311 }
00312 
00313 
00314 //-----------------------------------------------------------------------------
00315 // loadImage()
00316 //-----------------------------------------------------------------------------
00317 bool LLFloaterImagePreview::loadImage(const char *src_filename)
00318 {
00319         // U32 length = strlen(src_filename);
00320         const char* ext = strrchr(src_filename, '.');
00321         char error_message[MAX_STRING];
00322         error_message[0] = '\0';
00323 
00324         U32 codec = IMG_CODEC_INVALID;
00325         LLString temp_str;
00326         if( 0 == strnicmp(ext, ".bmp", 4) )
00327         {
00328                 codec = IMG_CODEC_BMP;
00329         }
00330         else if( 0 == strnicmp(ext, ".tga", 4) )
00331         {
00332                 codec = IMG_CODEC_TGA;
00333         }
00334         else if( 0 == strnicmp(ext, ".jpg", 4) || 0 == strnicmp(ext, ".jpeg", 5))
00335         {
00336                 codec = IMG_CODEC_JPEG;
00337         }
00338         else if( 0 == strnicmp(ext, ".png", 4) )
00339         {
00340                 codec = IMG_CODEC_PNG;
00341         }
00342 
00343         LLPointer<LLImageRaw> raw_image = new LLImageRaw;
00344 
00345         switch (codec)
00346         {
00347         case IMG_CODEC_BMP:
00348                 {
00349                         LLPointer<LLImageBMP> bmp_image = new LLImageBMP;
00350 
00351                         if (!bmp_image->load(src_filename))
00352                         {
00353                                 return false;
00354                         }
00355                         
00356                         if (!bmp_image->decode(raw_image))
00357                         {
00358                                 return false;
00359                         }
00360                 }
00361                 break;
00362         case IMG_CODEC_TGA:
00363                 {
00364                         LLPointer<LLImageTGA> tga_image = new LLImageTGA;
00365 
00366                         if (!tga_image->load(src_filename))
00367                         {
00368                                 return false;
00369                         }
00370                         
00371                         if (!tga_image->decode(raw_image))
00372                         {
00373                                 return false;
00374                         }
00375 
00376                         if(     (tga_image->getComponents() != 3) &&
00377                                 (tga_image->getComponents() != 4) )
00378                         {
00379                                 tga_image->setLastError( "Image files with less than 3 or more than 4 components are not supported." );
00380                                 return false;
00381                         }
00382                 }
00383                 break;
00384         case IMG_CODEC_JPEG:
00385                 {
00386                         LLPointer<LLImageJPEG> jpeg_image = new LLImageJPEG;
00387 
00388                         if (!jpeg_image->load(src_filename))
00389                         {
00390                                 return false;
00391                         }
00392                         
00393                         if (!jpeg_image->decode(raw_image))
00394                         {
00395                                 return false;
00396                         }
00397                 }
00398                 break;
00399         case IMG_CODEC_PNG:
00400                 {
00401                         LLPointer<LLImagePNG> png_image = new LLImagePNG;
00402 
00403                         if (!png_image->load(src_filename))
00404                         {
00405                                 return false;
00406                         }
00407                         
00408                         if (!png_image->decode(raw_image))
00409                         {
00410                                 return false;
00411                         }
00412                 }
00413                 break;
00414         default:
00415                 return false;
00416         }
00417 
00418         raw_image->biasedScaleToPowerOfTwo(1024);
00419         mRawImagep = raw_image;
00420         
00421         return true;
00422 }
00423 
00424 //-----------------------------------------------------------------------------
00425 // handleMouseDown()
00426 //-----------------------------------------------------------------------------
00427 BOOL LLFloaterImagePreview::handleMouseDown(S32 x, S32 y, MASK mask)
00428 {
00429         if (mPreviewRect.pointInRect(x, y))
00430         {
00431                 bringToFront( x, y );
00432                 gViewerWindow->setMouseCapture(this);
00433                 gViewerWindow->hideCursor();
00434                 mLastMouseX = x;
00435                 mLastMouseY = y;
00436                 return TRUE;
00437         }
00438 
00439         return LLFloater::handleMouseDown(x, y, mask);
00440 }
00441 
00442 //-----------------------------------------------------------------------------
00443 // handleMouseUp()
00444 //-----------------------------------------------------------------------------
00445 BOOL LLFloaterImagePreview::handleMouseUp(S32 x, S32 y, MASK mask)
00446 {
00447         gViewerWindow->setMouseCapture(FALSE);
00448         gViewerWindow->showCursor();
00449         return LLFloater::handleMouseUp(x, y, mask);
00450 }
00451 
00452 //-----------------------------------------------------------------------------
00453 // handleHover()
00454 //-----------------------------------------------------------------------------
00455 BOOL LLFloaterImagePreview::handleHover(S32 x, S32 y, MASK mask)
00456 {
00457         MASK local_mask = mask & ~MASK_ALT;
00458 
00459         if (mAvatarPreview && hasMouseCapture())
00460         {
00461                 if (local_mask == MASK_PAN)
00462                 {
00463                         // pan here
00464                         LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
00465                         if (iface && iface->getFirstSelectedIndex() <= 0)
00466                         {
00467                                 mPreviewImageRect.translate((F32)(x - mLastMouseX) * -0.005f * mPreviewImageRect.getWidth(), 
00468                                         (F32)(y - mLastMouseY) * -0.005f * mPreviewImageRect.getHeight());
00469                         }
00470                         else
00471                         {
00472                                 mAvatarPreview->pan((F32)(x - mLastMouseX) * -0.005f, (F32)(y - mLastMouseY) * -0.005f);
00473                                 mSculptedPreview->pan((F32)(x - mLastMouseX) * -0.005f, (F32)(y - mLastMouseY) * -0.005f);
00474                         }
00475                 }
00476                 else if (local_mask == MASK_ORBIT)
00477                 {
00478                         F32 yaw_radians = (F32)(x - mLastMouseX) * -0.01f;
00479                         F32 pitch_radians = (F32)(y - mLastMouseY) * 0.02f;
00480                         
00481                         mAvatarPreview->rotate(yaw_radians, pitch_radians);
00482                         mSculptedPreview->rotate(yaw_radians, pitch_radians);
00483                 }
00484                 else 
00485                 {
00486                         LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
00487                         if (iface && iface->getFirstSelectedIndex() <= 0)
00488                         {
00489                                 F32 zoom_amt = (F32)(y - mLastMouseY) * -0.002f;
00490                                 mPreviewImageRect.stretch(zoom_amt);
00491                         }
00492                         else
00493                         {
00494                                 F32 yaw_radians = (F32)(x - mLastMouseX) * -0.01f;
00495                                 F32 zoom_amt = (F32)(y - mLastMouseY) * 0.02f;
00496                                 
00497                                 mAvatarPreview->rotate(yaw_radians, 0.f);
00498                                 mAvatarPreview->zoom(zoom_amt);
00499                                 mSculptedPreview->rotate(yaw_radians, 0.f);
00500                                 mSculptedPreview->zoom(zoom_amt);
00501                         }
00502                 }
00503 
00504                 LLCtrlSelectionInterface* iface = childGetSelectionInterface("clothing_type_combo");
00505                 if (iface && iface->getFirstSelectedIndex() <= 0)
00506                 {
00507                         if (mPreviewImageRect.getWidth() > 1.f)
00508                         {
00509                                 mPreviewImageRect.stretch((1.f - mPreviewImageRect.getWidth()) * 0.5f);
00510                         }
00511                         else if (mPreviewImageRect.getWidth() < 0.1f)
00512                         {
00513                                 mPreviewImageRect.stretch((0.1f - mPreviewImageRect.getWidth()) * 0.5f);
00514                         }
00515 
00516                         if (mPreviewImageRect.getHeight() > 1.f)
00517                         {
00518                                 mPreviewImageRect.stretch((1.f - mPreviewImageRect.getHeight()) * 0.5f);
00519                         }
00520                         else if (mPreviewImageRect.getHeight() < 0.1f)
00521                         {
00522                                 mPreviewImageRect.stretch((0.1f - mPreviewImageRect.getHeight()) * 0.5f);
00523                         }
00524 
00525                         if (mPreviewImageRect.mLeft < 0.f)
00526                         {
00527                                 mPreviewImageRect.translate(-mPreviewImageRect.mLeft, 0.f);
00528                         }
00529                         else if (mPreviewImageRect.mRight > 1.f)
00530                         {
00531                                 mPreviewImageRect.translate(1.f - mPreviewImageRect.mRight, 0.f);
00532                         }
00533 
00534                         if (mPreviewImageRect.mBottom < 0.f)
00535                         {
00536                                 mPreviewImageRect.translate(0.f, -mPreviewImageRect.mBottom);
00537                         }
00538                         else if (mPreviewImageRect.mTop > 1.f)
00539                         {
00540                                 mPreviewImageRect.translate(0.f, 1.f - mPreviewImageRect.mTop);
00541                         }
00542                 }
00543                 else
00544                 {
00545                         mAvatarPreview->refresh();
00546                         mSculptedPreview->refresh();
00547                 }
00548 
00549                 LLUI::setCursorPositionLocal(this, mLastMouseX, mLastMouseY);
00550         }
00551 
00552         if (!mPreviewRect.pointInRect(x, y) || !mAvatarPreview || !mSculptedPreview)
00553         {
00554                 return LLFloater::handleHover(x, y, mask);
00555         }
00556         else if (local_mask == MASK_ORBIT)
00557         {
00558                 gViewerWindow->setCursor(UI_CURSOR_TOOLCAMERA);
00559         }
00560         else if (local_mask == MASK_PAN)
00561         {
00562                 gViewerWindow->setCursor(UI_CURSOR_TOOLPAN);
00563         }
00564         else
00565         {
00566                 gViewerWindow->setCursor(UI_CURSOR_TOOLZOOMIN);
00567         }
00568 
00569         return TRUE;
00570 }
00571 
00572 //-----------------------------------------------------------------------------
00573 // handleScrollWheel()
00574 //-----------------------------------------------------------------------------
00575 BOOL LLFloaterImagePreview::handleScrollWheel(S32 x, S32 y, S32 clicks)
00576 {
00577         if (mPreviewRect.pointInRect(x, y) && mAvatarPreview)
00578         {
00579                 mAvatarPreview->zoom((F32)clicks * -0.2f);
00580                 mAvatarPreview->refresh();
00581 
00582                 mSculptedPreview->zoom((F32)clicks * -0.2f);
00583                 mSculptedPreview->refresh();
00584         }
00585 
00586         return TRUE;
00587 }
00588 
00589 //-----------------------------------------------------------------------------
00590 // onMouseCaptureLost()
00591 //-----------------------------------------------------------------------------
00592 void LLFloaterImagePreview::onMouseCaptureLost(LLMouseHandler* handler)
00593 {
00594         gViewerWindow->showCursor();
00595 }
00596 
00597 
00598 //-----------------------------------------------------------------------------
00599 // LLImagePreviewAvatar
00600 //-----------------------------------------------------------------------------
00601 LLImagePreviewAvatar::LLImagePreviewAvatar(S32 width, S32 height) : LLDynamicTexture(width, height, 3, ORDER_MIDDLE, FALSE)
00602 {
00603         mNeedsUpdate = TRUE;
00604         mTargetJoint = NULL;
00605         mTargetMesh = NULL;
00606         mCameraDistance = 0.f;
00607         mCameraYaw = 0.f;
00608         mCameraPitch = 0.f;
00609         mCameraZoom = 1.f;
00610 
00611         mDummyAvatar = new LLVOAvatar(LLUUID::null, LL_PCODE_LEGACY_AVATAR, gAgent.getRegion());
00612         mDummyAvatar->createDrawable(&gPipeline);
00613         mDummyAvatar->mIsDummy = TRUE;
00614         mDummyAvatar->mSpecialRenderMode = 2;
00615         mDummyAvatar->setPositionAgent(LLVector3::zero);
00616         mDummyAvatar->slamPosition();
00617         mDummyAvatar->updateJointLODs();
00618         mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
00619         gPipeline.markVisible(mDummyAvatar->mDrawable, *gCamera);
00620 
00621         mTextureName = 0;
00622 }
00623 
00624 
00625 LLImagePreviewAvatar::~LLImagePreviewAvatar()
00626 {
00627         mDummyAvatar->markDead();
00628 }
00629 
00630 
00631 void LLImagePreviewAvatar::setPreviewTarget(const char* joint_name, const char* mesh_name, LLImageRaw* imagep, F32 distance, BOOL male) 
00632 { 
00633         mTargetJoint = mDummyAvatar->mRoot.findJoint(joint_name);
00634         // clear out existing test mesh
00635         if (mTargetMesh)
00636         {
00637                 mTargetMesh->setTestTexture(0);
00638         }
00639 
00640         if (male)
00641         {
00642                 mDummyAvatar->setVisualParamWeight( "male", 1.f );
00643                 mDummyAvatar->updateVisualParams();
00644                 mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
00645         }
00646         else
00647         {
00648                 mDummyAvatar->setVisualParamWeight( "male", 0.f );
00649                 mDummyAvatar->updateVisualParams();
00650                 mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
00651         }
00652         mDummyAvatar->mRoot.setVisible(FALSE, TRUE);
00653 
00654         mTargetMesh = (LLViewerJointMesh*)mDummyAvatar->mRoot.findJoint(mesh_name);
00655         mTargetMesh->setTestTexture(mTextureName);
00656         mTargetMesh->setVisible(TRUE, FALSE);
00657         mCameraDistance = distance;
00658         mCameraZoom = 1.f;
00659         mCameraPitch = 0.f;
00660         mCameraYaw = 0.f;
00661         mCameraOffset.clearVec();
00662 }
00663 
00664 //-----------------------------------------------------------------------------
00665 // update()
00666 //-----------------------------------------------------------------------------
00667 BOOL LLImagePreviewAvatar::render()
00668 {
00669         mNeedsUpdate = FALSE;
00670         LLVOAvatar* avatarp = mDummyAvatar;
00671 
00672         glMatrixMode(GL_PROJECTION);
00673         glPushMatrix();
00674         glLoadIdentity();
00675         glOrtho(0.0f, mWidth, 0.0f, mHeight, -1.0f, 1.0f);
00676 
00677         glMatrixMode(GL_MODELVIEW);
00678         glPushMatrix();
00679         glLoadIdentity();
00680 
00681         LLGLSUIDefault def;
00682         glColor4f(0.15f, 0.2f, 0.3f, 1.f);
00683 
00684         gl_rect_2d_simple( mWidth, mHeight );
00685 
00686         glMatrixMode(GL_PROJECTION);
00687         glPopMatrix();
00688 
00689         glMatrixMode(GL_MODELVIEW);
00690         glPopMatrix();
00691 
00692         LLVector3 target_pos = mTargetJoint->getWorldPosition();
00693 
00694         LLQuaternion camera_rot = LLQuaternion(mCameraPitch, LLVector3::y_axis) * 
00695                 LLQuaternion(mCameraYaw, LLVector3::z_axis);
00696 
00697         LLQuaternion av_rot = avatarp->mPelvisp->getWorldRotation() * camera_rot;
00698         gCamera->setOriginAndLookAt(
00699                 target_pos + ((LLVector3(mCameraDistance, 0.f, 0.f) + mCameraOffset) * av_rot),         // camera
00700                 LLVector3::z_axis,                                                                                                                                      // up
00701                 target_pos + (mCameraOffset  * av_rot) );                                                                                       // point of interest
00702 
00703         stop_glerror();
00704 
00705         gCamera->setAspect((F32)mWidth / mHeight);
00706         gCamera->setView(gCamera->getDefaultFOV() / mCameraZoom);
00707         gCamera->setPerspective(FALSE, mOrigin.mX, mOrigin.mY, mWidth, mHeight, FALSE);
00708 
00709         LLVertexBuffer::stopRender();
00710         avatarp->updateLOD();
00711         LLVertexBuffer::startRender();
00712 
00713         if (avatarp->mDrawable.notNull())
00714         {
00715                 LLGLDepthTest gls_depth(GL_TRUE, GL_TRUE);
00716                 // make sure alpha=0 shows avatar material color
00717                 LLGLDisable no_blend(GL_BLEND);
00718 
00719                 LLDrawPoolAvatar *avatarPoolp = (LLDrawPoolAvatar *)avatarp->mDrawable->getFace(0)->getPool();
00720                 
00721                 avatarPoolp->renderAvatars(avatarp);  // renders only one avatar
00722         }
00723 
00724         return TRUE;
00725 }
00726 
00727 //-----------------------------------------------------------------------------
00728 // refresh()
00729 //-----------------------------------------------------------------------------
00730 void LLImagePreviewAvatar::refresh()
00731 { 
00732         mNeedsUpdate = TRUE; 
00733 }
00734 
00735 //-----------------------------------------------------------------------------
00736 // rotate()
00737 //-----------------------------------------------------------------------------
00738 void LLImagePreviewAvatar::rotate(F32 yaw_radians, F32 pitch_radians)
00739 {
00740         mCameraYaw = mCameraYaw + yaw_radians;
00741 
00742         mCameraPitch = llclamp(mCameraPitch + pitch_radians, F_PI_BY_TWO * -0.8f, F_PI_BY_TWO * 0.8f);
00743 }
00744 
00745 //-----------------------------------------------------------------------------
00746 // zoom()
00747 //-----------------------------------------------------------------------------
00748 void LLImagePreviewAvatar::zoom(F32 zoom_amt)
00749 {
00750         mCameraZoom     = llclamp(mCameraZoom + zoom_amt, 1.f, 10.f);
00751 }
00752 
00753 void LLImagePreviewAvatar::pan(F32 right, F32 up)
00754 {
00755         mCameraOffset.mV[VY] = llclamp(mCameraOffset.mV[VY] + right * mCameraDistance / mCameraZoom, -1.f, 1.f);
00756         mCameraOffset.mV[VZ] = llclamp(mCameraOffset.mV[VZ] + up * mCameraDistance / mCameraZoom, -1.f, 1.f);
00757 }
00758 
00759 
00760 //-----------------------------------------------------------------------------
00761 // LLImagePreviewSculpted
00762 //-----------------------------------------------------------------------------
00763 
00764 LLImagePreviewSculpted::LLImagePreviewSculpted(S32 width, S32 height) : LLDynamicTexture(width, height, 3, ORDER_MIDDLE, FALSE)
00765 {
00766         mNeedsUpdate = TRUE;
00767         mCameraDistance = 0.f;
00768         mCameraYaw = 0.f;
00769         mCameraPitch = 0.f;
00770         mCameraZoom = 1.f;
00771         mTextureName = 0;
00772 
00773         LLVolumeParams volume_params;
00774         volume_params.setType(LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_CIRCLE);
00775         volume_params.setSculptID(LLUUID::null, LL_SCULPT_TYPE_SPHERE);
00776         mVolume = new LLVolume(volume_params, (F32) MAX_LOD);
00777 
00778         /*
00779         mDummyAvatar = new LLVOAvatar(LLUUID::null, LL_PCODE_LEGACY_AVATAR, gAgent.getRegion());
00780         mDummyAvatar->createDrawable(&gPipeline);
00781         mDummyAvatar->mIsDummy = TRUE;
00782         mDummyAvatar->mSpecialRenderMode = 2;
00783         mDummyAvatar->setPositionAgent(LLVector3::zero);
00784         mDummyAvatar->slamPosition();
00785         mDummyAvatar->updateJointLODs();
00786         mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
00787         gPipeline.markVisible(mDummyAvatar->mDrawable, *gCamera);
00788         mTextureName = 0;
00789         */
00790 }
00791 
00792 
00793 LLImagePreviewSculpted::~LLImagePreviewSculpted()
00794 {
00795         /*
00796         mDummyAvatar->markDead();
00797         */
00798 }
00799 
00800 
00801 void LLImagePreviewSculpted::setPreviewTarget(LLImageRaw* imagep, F32 distance)
00802 { 
00803         mCameraDistance = distance;
00804         mCameraZoom = 1.f;
00805         mCameraPitch = 0.f;
00806         mCameraYaw = 0.f;
00807         mCameraOffset.clearVec();
00808 
00809         if (imagep)
00810         {
00811                 mVolume->sculpt(imagep->getWidth(), imagep->getHeight(), imagep->getComponents(), imagep->getData(), 0);
00812         }
00813         
00814 }
00815 
00816 
00817 //-----------------------------------------------------------------------------
00818 // render()
00819 //-----------------------------------------------------------------------------
00820 BOOL LLImagePreviewSculpted::render()
00821 {
00822         mNeedsUpdate = FALSE;
00823 
00824         LLGLSUIDefault def;
00825         LLGLDisable no_blend(GL_BLEND);
00826         LLGLEnable cull(GL_CULL_FACE);
00827         LLGLDepthTest depth(GL_TRUE);
00828 
00829         glMatrixMode(GL_PROJECTION);
00830         glPushMatrix();
00831         glLoadIdentity();
00832         glOrtho(0.0f, mWidth, 0.0f, mHeight, -1.0f, 1.0f);
00833 
00834         glMatrixMode(GL_MODELVIEW);
00835         glPushMatrix();
00836         glLoadIdentity();
00837                 
00838         glColor4f(0.15f, 0.2f, 0.3f, 1.f);
00839 
00840         gl_rect_2d_simple( mWidth, mHeight );
00841 
00842         glMatrixMode(GL_PROJECTION);
00843         glPopMatrix();
00844 
00845         glMatrixMode(GL_MODELVIEW);
00846         glPopMatrix();
00847 
00848         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
00849         
00850         LLVector3 target_pos(0, 0, 0);
00851 
00852         LLQuaternion camera_rot = LLQuaternion(mCameraPitch, LLVector3::y_axis) * 
00853                 LLQuaternion(mCameraYaw, LLVector3::z_axis);
00854 
00855         LLQuaternion av_rot = camera_rot;
00856         gCamera->setOriginAndLookAt(
00857                 target_pos + ((LLVector3(mCameraDistance, 0.f, 0.f) + mCameraOffset) * av_rot),         // camera
00858                 LLVector3::z_axis,                                                                                                                                      // up
00859                 target_pos + (mCameraOffset  * av_rot) );                                                                                       // point of interest
00860 
00861         stop_glerror();
00862 
00863         gCamera->setAspect((F32) mWidth / mHeight);
00864         gCamera->setView(gCamera->getDefaultFOV() / mCameraZoom);
00865         gCamera->setPerspective(FALSE, mOrigin.mX, mOrigin.mY, mWidth, mHeight, FALSE);
00866 
00867         gPipeline.enableLightsAvatar(0.0);
00868 
00869                 
00870         glPushMatrix();
00871         glScalef(0.5, 0.5, 0.5);
00872         
00873         glBegin(GL_TRIANGLES);
00874         glColor3f(0.8f, 0.8f, 0.8f);
00875 
00876         const LLVolumeFace &vf = mVolume->getVolumeFace(0);
00877         S32 num_indices = (S32)vf.mIndices.size();
00878         for (U32 i = 0; (S32)i < num_indices; i++)
00879         {
00880                 LLVector3 normal = vf.mVertices[vf.mIndices[i]].mNormal;
00881                 normal.normVec();
00882                 glNormal3f(normal.mV[VX], normal.mV[VY], normal.mV[VZ]);
00883 
00884                 LLVector3 position = vf.mVertices[vf.mIndices[i]].mPosition;
00885                 glVertex3f(position.mV[VX], position.mV[VY], position.mV[VZ]);
00886         }
00887                 
00888         glEnd();
00889         
00890         glPopMatrix();
00891         
00892         return TRUE;
00893 }
00894 
00895 //-----------------------------------------------------------------------------
00896 // refresh()
00897 //-----------------------------------------------------------------------------
00898 void LLImagePreviewSculpted::refresh()
00899 { 
00900         mNeedsUpdate = TRUE; 
00901 }
00902 
00903 //-----------------------------------------------------------------------------
00904 // rotate()
00905 //-----------------------------------------------------------------------------
00906 void LLImagePreviewSculpted::rotate(F32 yaw_radians, F32 pitch_radians)
00907 {
00908         mCameraYaw = mCameraYaw + yaw_radians;
00909 
00910         mCameraPitch = llclamp(mCameraPitch + pitch_radians, F_PI_BY_TWO * -0.8f, F_PI_BY_TWO * 0.8f);
00911 }
00912 
00913 //-----------------------------------------------------------------------------
00914 // zoom()
00915 //-----------------------------------------------------------------------------
00916 void LLImagePreviewSculpted::zoom(F32 zoom_amt)
00917 {
00918         mCameraZoom     = llclamp(mCameraZoom + zoom_amt, 1.f, 10.f);
00919 }
00920 
00921 void LLImagePreviewSculpted::pan(F32 right, F32 up)
00922 {
00923         mCameraOffset.mV[VY] = llclamp(mCameraOffset.mV[VY] + right * mCameraDistance / mCameraZoom, -1.f, 1.f);
00924         mCameraOffset.mV[VZ] = llclamp(mCameraOffset.mV[VZ] + up * mCameraDistance / mCameraZoom, -1.f, 1.f);
00925 }