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 "llglimmediate.h"
00047 #include "llface.h"
00048 #include "lltextbox.h"
00049 #include "lltoolmgr.h"
00050 #include "llui.h"
00051 #include "llviewercamera.h"
00052 #include "llviewerwindow.h"
00053 #include "llvoavatar.h"
00054 #include "pipeline.h"
00055 #include "lluictrlfactory.h"
00056 #include "llviewerimagelist.h"
00057
00058
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
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
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
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
00147
00148
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
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 gGL.color3f(1.f, 1.f, 1.f);
00263 gGL.begin( LLVertexBuffer::QUADS );
00264 {
00265 gGL.texCoord2f(mPreviewImageRect.mLeft, mPreviewImageRect.mTop);
00266 gGL.vertex2i(PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
00267 gGL.texCoord2f(mPreviewImageRect.mLeft, mPreviewImageRect.mBottom);
00268 gGL.vertex2i(PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
00269 gGL.texCoord2f(mPreviewImageRect.mRight, mPreviewImageRect.mBottom);
00270 gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
00271 gGL.texCoord2f(mPreviewImageRect.mRight, mPreviewImageRect.mTop);
00272 gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
00273 }
00274 gGL.end();
00275
00276 LLImageGL::unbindTexture(0, GL_TEXTURE_2D);
00277
00278 stop_glerror();
00279 }
00280 else
00281 {
00282 if ((mAvatarPreview) && (mSculptedPreview))
00283 {
00284 gGL.color3f(1.f, 1.f, 1.f);
00285
00286 if (selected == 9)
00287 mSculptedPreview->bindTexture();
00288 else
00289 mAvatarPreview->bindTexture();
00290
00291 gGL.begin( LLVertexBuffer::QUADS );
00292 {
00293 gGL.texCoord2f(0.f, 1.f);
00294 gGL.vertex2i(PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
00295 gGL.texCoord2f(0.f, 0.f);
00296 gGL.vertex2i(PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
00297 gGL.texCoord2f(1.f, 0.f);
00298 gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_HPAD + PREF_BUTTON_HEIGHT + PREVIEW_HPAD);
00299 gGL.texCoord2f(1.f, 1.f);
00300 gGL.vertex2i(r.getWidth() - PREVIEW_HPAD, PREVIEW_TEXTURE_HEIGHT);
00301 }
00302 gGL.end();
00303
00304 if (selected == 9)
00305 mSculptedPreview->unbindTexture();
00306 else
00307 mAvatarPreview->unbindTexture();
00308 }
00309 }
00310 }
00311 }
00312
00313
00314
00315
00316
00317 bool LLFloaterImagePreview::loadImage(const char *src_filename)
00318 {
00319
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, 0.0f))
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, 0.0f))
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, 0.0f))
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
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
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
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
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
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
00591
00592
00593 void LLFloaterImagePreview::onMouseCaptureLostImagePreview(LLMouseHandler* handler)
00594 {
00595 gViewerWindow->showCursor();
00596 }
00597
00598
00599
00600
00601
00602 LLImagePreviewAvatar::LLImagePreviewAvatar(S32 width, S32 height) : LLDynamicTexture(width, height, 3, ORDER_MIDDLE, FALSE)
00603 {
00604 mNeedsUpdate = TRUE;
00605 mTargetJoint = NULL;
00606 mTargetMesh = NULL;
00607 mCameraDistance = 0.f;
00608 mCameraYaw = 0.f;
00609 mCameraPitch = 0.f;
00610 mCameraZoom = 1.f;
00611
00612 mDummyAvatar = new LLVOAvatar(LLUUID::null, LL_PCODE_LEGACY_AVATAR, gAgent.getRegion());
00613 mDummyAvatar->createDrawable(&gPipeline);
00614 mDummyAvatar->mIsDummy = TRUE;
00615 mDummyAvatar->mSpecialRenderMode = 2;
00616 mDummyAvatar->setPositionAgent(LLVector3::zero);
00617 mDummyAvatar->slamPosition();
00618 mDummyAvatar->updateJointLODs();
00619 mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
00620
00621
00622 mTextureName = 0;
00623 }
00624
00625
00626 LLImagePreviewAvatar::~LLImagePreviewAvatar()
00627 {
00628 mDummyAvatar->markDead();
00629 }
00630
00631
00632 void LLImagePreviewAvatar::setPreviewTarget(const char* joint_name, const char* mesh_name, LLImageRaw* imagep, F32 distance, BOOL male)
00633 {
00634 mTargetJoint = mDummyAvatar->mRoot.findJoint(joint_name);
00635
00636 if (mTargetMesh)
00637 {
00638 mTargetMesh->setTestTexture(0);
00639 }
00640
00641 if (male)
00642 {
00643 mDummyAvatar->setVisualParamWeight( "male", 1.f );
00644 mDummyAvatar->updateVisualParams();
00645 mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
00646 }
00647 else
00648 {
00649 mDummyAvatar->setVisualParamWeight( "male", 0.f );
00650 mDummyAvatar->updateVisualParams();
00651 mDummyAvatar->updateGeometry(mDummyAvatar->mDrawable);
00652 }
00653 mDummyAvatar->mRoot.setVisible(FALSE, TRUE);
00654
00655 mTargetMesh = (LLViewerJointMesh*)mDummyAvatar->mRoot.findJoint(mesh_name);
00656 mTargetMesh->setTestTexture(mTextureName);
00657 mTargetMesh->setVisible(TRUE, FALSE);
00658 mCameraDistance = distance;
00659 mCameraZoom = 1.f;
00660 mCameraPitch = 0.f;
00661 mCameraYaw = 0.f;
00662 mCameraOffset.clearVec();
00663 }
00664
00665
00666
00667
00668 BOOL LLImagePreviewAvatar::render()
00669 {
00670 mNeedsUpdate = FALSE;
00671 LLVOAvatar* avatarp = mDummyAvatar;
00672
00673 glMatrixMode(GL_PROJECTION);
00674 gGL.pushMatrix();
00675 glLoadIdentity();
00676 glOrtho(0.0f, mWidth, 0.0f, mHeight, -1.0f, 1.0f);
00677
00678 glMatrixMode(GL_MODELVIEW);
00679 gGL.pushMatrix();
00680 glLoadIdentity();
00681
00682 LLGLSUIDefault def;
00683 gGL.color4f(0.15f, 0.2f, 0.3f, 1.f);
00684
00685 gl_rect_2d_simple( mWidth, mHeight );
00686
00687 glMatrixMode(GL_PROJECTION);
00688 gGL.popMatrix();
00689
00690 glMatrixMode(GL_MODELVIEW);
00691 gGL.popMatrix();
00692
00693 gGL.flush();
00694 LLVector3 target_pos = mTargetJoint->getWorldPosition();
00695
00696 LLQuaternion camera_rot = LLQuaternion(mCameraPitch, LLVector3::y_axis) *
00697 LLQuaternion(mCameraYaw, LLVector3::z_axis);
00698
00699 LLQuaternion av_rot = avatarp->mPelvisp->getWorldRotation() * camera_rot;
00700 LLViewerCamera::getInstance()->setOriginAndLookAt(
00701 target_pos + ((LLVector3(mCameraDistance, 0.f, 0.f) + mCameraOffset) * av_rot),
00702 LLVector3::z_axis,
00703 target_pos + (mCameraOffset * av_rot) );
00704
00705 stop_glerror();
00706
00707 LLViewerCamera::getInstance()->setAspect((F32)mWidth / mHeight);
00708 LLViewerCamera::getInstance()->setView(LLViewerCamera::getInstance()->getDefaultFOV() / mCameraZoom);
00709 LLViewerCamera::getInstance()->setPerspective(FALSE, mOrigin.mX, mOrigin.mY, mWidth, mHeight, FALSE);
00710
00711 LLVertexBuffer::unbind();
00712 avatarp->updateLOD();
00713
00714
00715 if (avatarp->mDrawable.notNull())
00716 {
00717 LLGLDepthTest gls_depth(GL_TRUE, GL_TRUE);
00718
00719 LLGLDisable no_blend(GL_BLEND);
00720
00721 LLDrawPoolAvatar *avatarPoolp = (LLDrawPoolAvatar *)avatarp->mDrawable->getFace(0)->getPool();
00722
00723 avatarPoolp->renderAvatars(avatarp);
00724 }
00725
00726 gGL.color4f(1,1,1,1);
00727 return TRUE;
00728 }
00729
00730
00731
00732
00733 void LLImagePreviewAvatar::refresh()
00734 {
00735 mNeedsUpdate = TRUE;
00736 }
00737
00738
00739
00740
00741 void LLImagePreviewAvatar::rotate(F32 yaw_radians, F32 pitch_radians)
00742 {
00743 mCameraYaw = mCameraYaw + yaw_radians;
00744
00745 mCameraPitch = llclamp(mCameraPitch + pitch_radians, F_PI_BY_TWO * -0.8f, F_PI_BY_TWO * 0.8f);
00746 }
00747
00748
00749
00750
00751 void LLImagePreviewAvatar::zoom(F32 zoom_amt)
00752 {
00753 mCameraZoom = llclamp(mCameraZoom + zoom_amt, 1.f, 10.f);
00754 }
00755
00756 void LLImagePreviewAvatar::pan(F32 right, F32 up)
00757 {
00758 mCameraOffset.mV[VY] = llclamp(mCameraOffset.mV[VY] + right * mCameraDistance / mCameraZoom, -1.f, 1.f);
00759 mCameraOffset.mV[VZ] = llclamp(mCameraOffset.mV[VZ] + up * mCameraDistance / mCameraZoom, -1.f, 1.f);
00760 }
00761
00762
00763
00764
00765
00766
00767 LLImagePreviewSculpted::LLImagePreviewSculpted(S32 width, S32 height) : LLDynamicTexture(width, height, 3, ORDER_MIDDLE, FALSE)
00768 {
00769 mNeedsUpdate = TRUE;
00770 mCameraDistance = 0.f;
00771 mCameraYaw = 0.f;
00772 mCameraPitch = 0.f;
00773 mCameraZoom = 1.f;
00774 mTextureName = 0;
00775
00776 LLVolumeParams volume_params;
00777 volume_params.setType(LL_PCODE_PROFILE_CIRCLE, LL_PCODE_PATH_CIRCLE);
00778 volume_params.setSculptID(LLUUID::null, LL_SCULPT_TYPE_SPHERE);
00779 mVolume = new LLVolume(volume_params, (F32) MAX_LOD);
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793 }
00794
00795
00796 LLImagePreviewSculpted::~LLImagePreviewSculpted()
00797 {
00798
00799
00800
00801 }
00802
00803
00804 void LLImagePreviewSculpted::setPreviewTarget(LLImageRaw* imagep, F32 distance)
00805 {
00806 mCameraDistance = distance;
00807 mCameraZoom = 1.f;
00808 mCameraPitch = 0.f;
00809 mCameraYaw = 0.f;
00810 mCameraOffset.clearVec();
00811
00812 if (imagep)
00813 {
00814 mVolume->sculpt(imagep->getWidth(), imagep->getHeight(), imagep->getComponents(), imagep->getData(), 0);
00815 }
00816
00817 }
00818
00819
00820
00821
00822
00823 BOOL LLImagePreviewSculpted::render()
00824 {
00825 mNeedsUpdate = FALSE;
00826
00827 LLGLSUIDefault def;
00828 LLGLDisable no_blend(GL_BLEND);
00829 LLGLEnable cull(GL_CULL_FACE);
00830 LLGLDepthTest depth(GL_TRUE);
00831
00832 glMatrixMode(GL_PROJECTION);
00833 gGL.pushMatrix();
00834 glLoadIdentity();
00835 glOrtho(0.0f, mWidth, 0.0f, mHeight, -1.0f, 1.0f);
00836
00837 glMatrixMode(GL_MODELVIEW);
00838 gGL.pushMatrix();
00839 glLoadIdentity();
00840
00841 gGL.color4f(0.15f, 0.2f, 0.3f, 1.f);
00842
00843 gl_rect_2d_simple( mWidth, mHeight );
00844
00845 glMatrixMode(GL_PROJECTION);
00846 gGL.popMatrix();
00847
00848 glMatrixMode(GL_MODELVIEW);
00849 gGL.popMatrix();
00850
00851 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
00852
00853 LLVector3 target_pos(0, 0, 0);
00854
00855 LLQuaternion camera_rot = LLQuaternion(mCameraPitch, LLVector3::y_axis) *
00856 LLQuaternion(mCameraYaw, LLVector3::z_axis);
00857
00858 LLQuaternion av_rot = camera_rot;
00859 LLViewerCamera::getInstance()->setOriginAndLookAt(
00860 target_pos + ((LLVector3(mCameraDistance, 0.f, 0.f) + mCameraOffset) * av_rot),
00861 LLVector3::z_axis,
00862 target_pos + (mCameraOffset * av_rot) );
00863
00864 stop_glerror();
00865
00866 LLViewerCamera::getInstance()->setAspect((F32) mWidth / mHeight);
00867 LLViewerCamera::getInstance()->setView(LLViewerCamera::getInstance()->getDefaultFOV() / mCameraZoom);
00868 LLViewerCamera::getInstance()->setPerspective(FALSE, mOrigin.mX, mOrigin.mY, mWidth, mHeight, FALSE);
00869
00870 gPipeline.enableLightsAvatar();
00871
00872 gGL.pushMatrix();
00873 glScalef(0.5, 0.5, 0.5);
00874
00875 const LLVolumeFace &vf = mVolume->getVolumeFace(0);
00876 U32 num_indices = vf.mIndices.size();
00877 U32 num_vertices = vf.mVertices.size();
00878
00879 if (num_vertices > 0 && num_indices > 0)
00880 {
00881 glEnableClientState(GL_NORMAL_ARRAY);
00882
00883 F32* vertices = new F32[num_vertices * 3];
00884 F32* normals = new F32[num_vertices * 3];
00885
00886 for (U32 i = 0; (S32)i < num_vertices; i++)
00887 {
00888 LLVector3 position = vf.mVertices[i].mPosition;
00889 vertices[i*3] = position.mV[VX];
00890 vertices[i*3+1] = position.mV[VY];
00891 vertices[i*3+2] = position.mV[VZ];
00892
00893 LLVector3 normal = vf.mVertices[i].mNormal;
00894 normals[i*3] = normal.mV[VX];
00895 normals[i*3+1] = normal.mV[VY];
00896 normals[i*3+2] = normal.mV[VZ];
00897 }
00898
00899
00900 U16* indices = new U16[num_indices];
00901 for (U16 i = 0; i < num_indices; i++)
00902 {
00903 indices[i] = vf.mIndices[i];
00904 }
00905
00906 gGL.color3f(0.4f, 0.4f, 0.4f);
00907 glVertexPointer(3, GL_FLOAT, 0, (void *)vertices);
00908 glNormalPointer(GL_FLOAT, 0, (void *)normals);
00909 glDrawRangeElements(GL_TRIANGLES, 0, num_vertices-1, num_indices, GL_UNSIGNED_SHORT, (void *)indices);
00910
00911 gGL.popMatrix();
00912 glDisableClientState(GL_NORMAL_ARRAY);
00913
00914 delete [] indices;
00915 delete [] vertices;
00916 delete [] normals;
00917 }
00918
00919 return TRUE;
00920 }
00921
00922
00923
00924
00925 void LLImagePreviewSculpted::refresh()
00926 {
00927 mNeedsUpdate = TRUE;
00928 }
00929
00930
00931
00932
00933 void LLImagePreviewSculpted::rotate(F32 yaw_radians, F32 pitch_radians)
00934 {
00935 mCameraYaw = mCameraYaw + yaw_radians;
00936
00937 mCameraPitch = llclamp(mCameraPitch + pitch_radians, F_PI_BY_TWO * -0.8f, F_PI_BY_TWO * 0.8f);
00938 }
00939
00940
00941
00942
00943 void LLImagePreviewSculpted::zoom(F32 zoom_amt)
00944 {
00945 mCameraZoom = llclamp(mCameraZoom + zoom_amt, 1.f, 10.f);
00946 }
00947
00948 void LLImagePreviewSculpted::pan(F32 right, F32 up)
00949 {
00950 mCameraOffset.mV[VY] = llclamp(mCameraOffset.mV[VY] + right * mCameraDistance / mCameraZoom, -1.f, 1.f);
00951 mCameraOffset.mV[VZ] = llclamp(mCameraOffset.mV[VZ] + up * mCameraDistance / mCameraZoom, -1.f, 1.f);
00952 }