void
WebGLFramebuffer::Attachment::FinalizeAttachment(gl::GLContext* gl,
FBAttachment attachmentLoc) const
{
if (!mNeedsFinalize)
return;
mNeedsFinalize = false;
if (!HasImage()) {
if (attachmentLoc == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
LOCAL_GL_DEPTH_ATTACHMENT,
LOCAL_GL_RENDERBUFFER, 0);
gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
LOCAL_GL_STENCIL_ATTACHMENT,
LOCAL_GL_RENDERBUFFER, 0);
} else {
gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
attachmentLoc.get(),
LOCAL_GL_RENDERBUFFER, 0);
}
return;
}
MOZ_ASSERT(HasImage());
if (Texture()) {
MOZ_ASSERT(gl == Texture()->Context()->GL());
const GLenum imageTarget = ImageTarget().get();
const GLint mipLevel = MipLevel();
const GLuint glName = Texture()->GLName();
if (attachmentLoc == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
LOCAL_GL_DEPTH_ATTACHMENT, imageTarget,
glName, mipLevel);
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
LOCAL_GL_STENCIL_ATTACHMENT, imageTarget,
glName, mipLevel);
} else {
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, attachmentLoc.get(),
imageTarget, glName, mipLevel);
}
return;
}
if (Renderbuffer()) {
Renderbuffer()->FramebufferRenderbuffer(attachmentLoc);
return;
}
MOZ_ASSERT(false, "Should not get here.");
}
void ImageWidget::Clear()
{
if(HasImage())
{
_originalMask.reset();
_alternativeMask.reset();
delete _highlightConfig;
_highlightConfig = new ThresholdConfig();
_highlightConfig->InitializeLengthsSingleSample();
_segmentedImage.reset();
}
if(_horiScale != 0) {
delete _horiScale;
_horiScale = 0;
}
if(_vertScale != 0) {
delete _vertScale;
_vertScale = 0;
}
if(_colorScale != 0) {
delete _colorScale;
_colorScale = 0;
}
if(_plotTitle != 0) {
delete _plotTitle;
_plotTitle = 0;
}
}
void
ProgressTracker::SyncNotifyProgress(Progress aProgress,
const nsIntRect& aInvalidRect
/* = nsIntRect() */)
{
MOZ_ASSERT(NS_IsMainThread(), "Use mObservers on main thread only");
// Don't unblock onload if we're not blocked.
Progress progress = Difference(aProgress);
if (!((mProgress | progress) & FLAG_ONLOAD_BLOCKED)) {
progress &= ~FLAG_ONLOAD_UNBLOCKED;
}
// XXX(seth): Hack to work around the fact that some observers have bugs and
// need to get onload blocking notifications multiple times. We should fix
// those observers and remove this.
if ((aProgress & FLAG_DECODE_COMPLETE) &&
(mProgress & FLAG_ONLOAD_BLOCKED) &&
(mProgress & FLAG_ONLOAD_UNBLOCKED)) {
progress |= FLAG_ONLOAD_BLOCKED | FLAG_ONLOAD_UNBLOCKED;
}
// Apply the changes.
mProgress |= progress;
CheckProgressConsistency(mProgress);
// Send notifications.
SyncNotifyInternal(mObservers, HasImage(), progress, aInvalidRect);
if (progress & FLAG_HAS_ERROR) {
FireFailureNotification();
}
}
//=======================================================================
//function : HasImage
//purpose :
//=======================================================================
Standard_Boolean GEOMAlgo_Gluer2::HasImage(const TopoDS_Shape& aC)
{
Standard_Boolean bRet;
TopAbs_ShapeEnum aType;
TopoDS_Iterator aItC;
//
bRet=Standard_False;
aItC.Initialize(aC);
for (; aItC.More(); aItC.Next()) {
const TopoDS_Shape& aCx=aItC.Value();
aType=aCx.ShapeType();
//
if (aType==TopAbs_COMPOUND) {
bRet=HasImage(aCx);
if (bRet) {
return bRet;
}
}
else {
bRet=myOrigins.IsBound(aCx);
if (bRet) {
return bRet;
}
}
}
//
bRet=myOrigins.IsBound(aC);
//
return bRet;
}
void
ImageView::MouseDown(BPoint point)
{
if (!HasImage())
return;
// Only accept left button clicks
BMessage *pmsg = Window()->CurrentMessage();
int32 button = pmsg->FindInt32("buttons");
if (button != B_PRIMARY_MOUSE_BUTTON)
return;
// Tell BeOS to setup a Drag/Drop operation
//
// (When the image is dropped, BeOS sends
// the following message to ImageWindow,
// which causes it to call ImageView::SetImage())
BMessage msg(B_SIMPLE_DATA);
msg.AddInt32("be:actions", B_COPY_TARGET);
msg.AddString("be:filetypes", "application/octet-stream");
msg.AddString("be:types", "application/octet-stream");
msg.AddString("be:clip_name", "Bitmap");
DragMessage(&msg, Bounds());
}
void
ImageView::AdjustScrollBars()
{
BRect rctview = Bounds(), rctbitmap(0, 0, 0, 0);
if (HasImage())
rctbitmap = fpbitmap->Bounds();
float prop, range;
BScrollBar *psb = ScrollBar(B_HORIZONTAL);
if (psb) {
range = rctbitmap.Width() + (BORDER_WIDTH * 2) - rctview.Width();
if (range < 0) range = 0;
prop = rctview.Width() / (rctbitmap.Width() + (BORDER_WIDTH * 2));
if (prop > 1.0f) prop = 1.0f;
psb->SetRange(0, range);
psb->SetProportion(prop);
psb->SetSteps(10, 100);
}
psb = ScrollBar(B_VERTICAL);
if (psb) {
range = rctbitmap.Height() + (BORDER_HEIGHT * 2) - rctview.Height();
if (range < 0) range = 0;
prop = rctview.Height() / (rctbitmap.Height() + (BORDER_HEIGHT * 2));
if (prop > 1.0f) prop = 1.0f;
psb->SetRange(0, range);
psb->SetProportion(prop);
psb->SetSteps(10, 100);
}
}
void
WebGLFramebuffer::AttachPoint::FinalizeAttachment(gl::GLContext* gl,
FBAttachment attachmentLoc) const
{
if (!HasImage()) {
switch (attachmentLoc.get()) {
case LOCAL_GL_DEPTH_ATTACHMENT:
case LOCAL_GL_STENCIL_ATTACHMENT:
case LOCAL_GL_DEPTH_STENCIL_ATTACHMENT:
break;
default:
gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, attachmentLoc.get(),
LOCAL_GL_RENDERBUFFER, 0);
break;
}
return;
}
MOZ_ASSERT(HasImage());
if (Texture()) {
MOZ_ASSERT(gl == Texture()->Context()->GL());
const GLenum imageTarget = ImageTarget().get();
const GLint mipLevel = MipLevel();
const GLuint glName = Texture()->GLName();
if (attachmentLoc == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_DEPTH_ATTACHMENT,
imageTarget, glName, mipLevel);
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_STENCIL_ATTACHMENT,
imageTarget, glName, mipLevel);
} else {
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, attachmentLoc.get(),
imageTarget, glName, mipLevel);
}
return;
}
if (Renderbuffer()) {
Renderbuffer()->FramebufferRenderbuffer(attachmentLoc);
return;
}
MOZ_CRASH();
}
void
ImageView::FrameResized(float width, float height)
{
AdjustScrollBars();
if (!HasImage())
Invalidate();
}
//=======================================================================
//function : FillContainers
//purpose :
//=======================================================================
void GEOMAlgo_Gluer2::FillContainers(const TopAbs_ShapeEnum aType)
{
Standard_Boolean bHasImage, bToReverse;
Standard_Integer i, aNbW;
TopoDS_Shape aWnew, aEnew;
TopoDS_Iterator aItS;
BRep_Builder aBB;
TopTools_IndexedMapOfShape aMW;
TopTools_MapOfShape aMFence;
//
myErrorStatus=0;
myWarningStatus=0;
//
TopExp::MapShapes(myArgument, aType, aMW);
//
aNbW=aMW.Extent();
for (i=1; i<=aNbW; ++i) {
const TopoDS_Shape& aW=aMW(i);
//
if (!aMFence.Add(aW)) {
continue;
}
//
bHasImage=HasImage(aW);
if (!bHasImage) {
continue;
}
//
GEOMAlgo_Tools3D::MakeContainer(aType, aWnew);
aWnew.Orientation(aW.Orientation());
//
aItS.Initialize(aW);
for (; aItS.More(); aItS.Next()) {
const TopoDS_Shape& aE=aItS.Value();
if (myOrigins.IsBound(aE)) {
aEnew=myOrigins.Find(aE);
//
bToReverse=GEOMAlgo_Tools3D::IsSplitToReverse(aEnew, aE, myContext);
if (bToReverse) {
aEnew.Reverse();
}
//
aBB.Add(aWnew, aEnew);
}
else {
aBB.Add(aWnew, aE);
}
}
//
//myImages / myOrigins
TopTools_ListOfShape aLSD;
//
aLSD.Append(aW);
myImages.Bind(aWnew, aLSD);
myOrigins.Bind(aW, aWnew);
//
}//for (i=1; i<=aNbE; ++i) {
}
//=======================================================================
//function : BuildResult
//purpose :
//=======================================================================
void GEOMAlgo_Gluer2::BuildResult()
{
Standard_Boolean bHasImage;
TopoDS_Shape aCnew, aCXnew;
TopoDS_Iterator aItC;
BRep_Builder aBB;
//
myErrorStatus=0;
myWarningStatus=0;
//
aItC.Initialize(myArgument);
for (; aItC.More(); aItC.Next()) {
const TopoDS_Shape& aCx=aItC.Value();
bHasImage=HasImage(aCx);
if (bHasImage) {
break;
}
}
//
if (!bHasImage) {
myShape=myArgument;
return;
}
//
GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew);
//
aItC.Initialize(myArgument);
for (; aItC.More(); aItC.Next()) {
const TopoDS_Shape& aCX=aItC.Value();
if (myOrigins.IsBound(aCX)) {
aCXnew=myOrigins.Find(aCX);
aCXnew.Orientation(aCX.Orientation());
aBB.Add(aCnew, aCXnew);
}
else {
aBB.Add(aCnew, aCX);
}
}
//
if (!myKeepNonSolids) {
Standard_Integer i, aNb;
TopoDS_Shape aCnew1;
TopTools_IndexedMapOfShape aM;
//
GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew1);
//
TopExp::MapShapes(aCnew, TopAbs_SOLID, aM);
aNb=aM.Extent();
for (i=1; i<=aNb; ++i) {
const TopoDS_Shape& aS=aM(i);
aBB.Add(aCnew1, aS);
}
aCnew=aCnew1;
}
//
myShape=aCnew;
}
void ImageWidget::Update()
{
if(HasImage())
{
Glib::RefPtr<Gdk::Window> window = get_window();
if(window != 0 && get_width() > 0 && get_height() > 0)
update(window->create_cairo_context(), get_width(), get_height());
}
}
bool ImageWidget::onButtonReleased(GdkEventButton *event)
{
if(HasImage())
{
int posX, posY;
if(toUnits(event->x, event->y, posX, posY))
_onButtonReleased(posX, posY);
}
return true;
}
//=======================================================================
//function : FillBRepShapes
//purpose :
//=======================================================================
void GEOMAlgo_Gluer2::FillBRepShapes(const TopAbs_ShapeEnum theType)
{
Standard_Boolean bHasImage, bIsToWork;
Standard_Integer i, aNbE;
TopoDS_Iterator aItS;
TopoDS_Shape aEnew;
TopTools_IndexedMapOfShape aME;
TopTools_MapOfShape aMFence;
TopTools_ListIteratorOfListOfShape aItLS;
//
myErrorStatus=0;
myWarningStatus=0;
//
TopExp::MapShapes(myArgument, theType, aME);
//
aNbE=aME.Extent();
for (i=1; i<=aNbE; ++i) {
const TopoDS_Shape& aE=aME(i);
//
if (!aMFence.Add(aE)) {
continue;
}
//
bIsToWork=myOriginsToWork.IsBound(aE);
bHasImage=HasImage(aE);
if (!bHasImage && !bIsToWork) {
continue;
}
//
MakeBRepShapes(aE, aEnew);
//
//myImages / myOrigins
if (bIsToWork) {
const TopoDS_Shape& aSkey=myOriginsToWork.Find(aE);
const TopTools_ListOfShape& aLSD=myImagesToWork.Find(aSkey);
//
myImages.Bind(aEnew, aLSD);
//
aItLS.Initialize(aLSD);
for (; aItLS.More(); aItLS.Next()) {
const TopoDS_Shape& aEx=aItLS.Value();
myOrigins.Bind(aEx, aEnew);
//
aMFence.Add(aEx);
}
}
else {
TopTools_ListOfShape aLSD;
//
aLSD.Append(aE);
myImages.Bind(aEnew, aLSD);
myOrigins.Bind(aE, aEnew);
}
}//for (i=1; i<=aNbF; ++i) {
}
void ImageWidget::SavePng(const std::string &filename)
{
unsigned width = get_width(), height = get_height();
Cairo::RefPtr<Cairo::ImageSurface> surface = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, width, height);
Cairo::RefPtr<Cairo::Context> cairo = Cairo::Context::create(surface);
if(HasImage())
{
AOLogger::Debug << "Saving PNG of " << get_width() << " x " << get_height() << "\n";
update(cairo, width, height);
}
surface->write_to_png(filename);
}
HRESULT BMPanvas::SaveImage(CString name)
{
HRESULT ret = E_FAIL;
CImage TI;
if(HasImage())
{
TI.Attach(GetHBMP(BMP_DETACH));
ret=TI.Save(name,ImageFormatPNG);
Attach(TI.Detach());
}
return ret;
}
void ImageWidget::SaveSvg(const std::string &filename)
{
unsigned width = get_width(), height = get_height();
Cairo::RefPtr<Cairo::SvgSurface> surface = Cairo::SvgSurface::create(filename, width, height);
Cairo::RefPtr<Cairo::Context> cairo = Cairo::Context::create(surface);
if(HasImage())
{
AOLogger::Debug << "Saving SVG of " << get_width() << " x " << get_height() << "\n";
update(cairo, width, height);
}
cairo->show_page();
surface->finish();
}
void
ImageView::Draw(BRect rect)
{
if (HasImage()) {
// Draw black rectangle around image
StrokeRect(
BRect(BORDER_WIDTH - PEN_SIZE,
BORDER_HEIGHT - PEN_SIZE,
fpbitmap->Bounds().Width() + BORDER_WIDTH + PEN_SIZE,
fpbitmap->Bounds().Height() + BORDER_HEIGHT + PEN_SIZE));
DrawBitmap(fpbitmap, BPoint(BORDER_WIDTH, BORDER_HEIGHT));
}
}
void ImageWidget::SavePdf(const std::string &filename)
{
unsigned width = get_width(), height = get_height();
Cairo::RefPtr<Cairo::PdfSurface> surface = Cairo::PdfSurface::create(filename, width, height);
Cairo::RefPtr<Cairo::Context> cairo = Cairo::Context::create(surface);
if(HasImage())
{
AOLogger::Debug << "Saving PDF of " <<get_width() << " x " << get_height() << "\n";
update(cairo, width, height);
}
cairo->show_page();
// We finish the surface. This might be required, because some of the subclasses store the cairo context. In that
// case, it won't be written.
surface->finish();
}
const WebGLRectangleObject&
WebGLFramebuffer::AttachPoint::RectangleObject() const
{
MOZ_ASSERT(HasImage(),
"Make sure it has an image before requesting the rectangle.");
if (Texture()) {
MOZ_ASSERT(Texture()->HasImageInfoAt(mTexImageTarget, mTexImageLevel));
return Texture()->ImageInfoAt(mTexImageTarget, mTexImageLevel);
}
if (Renderbuffer())
return *Renderbuffer();
MOZ_CRASH("Should not get here.");
}
bool ImageWidget::onMotion(GdkEventMotion *event)
{
if(HasImage())
{
int posX, posY;
if(toUnits(event->x, event->y, posX, posY))
{
_mouseIsIn = true;
_onMouseMoved(posX, posY);
} else if(_mouseIsIn) {
_onMouseLeft();
_mouseIsIn = false;
}
}
return true;
}
bool
WebGLFBAttachPoint::HasUninitializedImageData() const
{
if (!HasImage())
return false;
if (mRenderbufferPtr)
return mRenderbufferPtr->HasUninitializedImageData();
MOZ_ASSERT(mTexturePtr);
auto& imageInfo = mTexturePtr->ImageInfoAt(mTexImageTarget, mTexImageLevel);
MOZ_ASSERT(imageInfo.IsDefined());
return !imageInfo.IsDataInitialized();
}
bool
WebGLFramebuffer::AttachPoint::HasAlpha() const
{
MOZ_ASSERT(HasImage());
if (Texture() &&
Texture()->HasImageInfoAt(mTexImageTarget, mTexImageLevel))
{
return FormatHasAlpha(Texture()->ImageInfoAt(mTexImageTarget,
mTexImageLevel).EffectiveInternalFormat());
}
if (Renderbuffer())
return FormatHasAlpha(Renderbuffer()->InternalFormat());
return false;
}
void
WebGLFBAttachPoint::Size(uint32_t* const out_width, uint32_t* const out_height) const
{
MOZ_ASSERT(HasImage());
if (Renderbuffer()) {
*out_width = Renderbuffer()->Width();
*out_height = Renderbuffer()->Height();
return;
}
MOZ_ASSERT(Texture());
MOZ_ASSERT(Texture()->ImageInfoAt(mTexImageTarget, mTexImageLevel).IsDefined());
const auto& imageInfo = Texture()->ImageInfoAt(mTexImageTarget, mTexImageLevel);
*out_width = imageInfo.mWidth;
*out_height = imageInfo.mHeight;
}
bool
WebGLFramebuffer::AttachPoint::HasUninitializedImageData() const
{
if (!HasImage())
return false;
if (Renderbuffer())
return Renderbuffer()->HasUninitializedImageData();
if (Texture()) {
MOZ_ASSERT(Texture()->HasImageInfoAt(mTexImageTarget, mTexImageLevel));
return Texture()->ImageInfoAt(mTexImageTarget,
mTexImageLevel).HasUninitializedImageData();
}
MOZ_ASSERT(false, "Should not get here.");
return false;
}
void
WebGLFramebuffer::AttachPoint::SetImageDataStatus(WebGLImageDataStatus newStatus)
{
if (!HasImage())
return;
if (Renderbuffer()) {
Renderbuffer()->SetImageDataStatus(newStatus);
return;
}
if (Texture()) {
Texture()->SetImageDataStatus(mTexImageTarget, mTexImageLevel,
newStatus);
return;
}
MOZ_ASSERT(false, "Should not get here.");
}
bool
WebGLFBAttachPoint::IsComplete(WebGLContext* webgl) const
{
MOZ_ASSERT(IsDefined());
if (!HasImage())
return false;
uint32_t width;
uint32_t height;
Size(&width, &height);
if (!width || !height)
return false;
auto formatUsage = Format();
if (!formatUsage->isRenderable)
return false;
auto format = formatUsage->format;
if (webgl->IsWebGL2()) {
if (mAttachmentPoint == LOCAL_GL_DEPTH_ATTACHMENT)
return format->hasDepth;
if (mAttachmentPoint == LOCAL_GL_STENCIL_ATTACHMENT)
return format->hasStencil;
if (mAttachmentPoint == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT)
MOZ_CRASH("No DEPTH_STENCIL_ATTACHMENT in WebGL 2.");
} else {
if (mAttachmentPoint == LOCAL_GL_DEPTH_ATTACHMENT)
return format->hasDepth && !format->hasStencil;
if (mAttachmentPoint == LOCAL_GL_STENCIL_ATTACHMENT)
return !format->hasDepth && format->hasStencil;
if (mAttachmentPoint == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT)
return format->hasDepth && format->hasStencil;
}
MOZ_ASSERT(mAttachmentPoint >= LOCAL_GL_COLOR_ATTACHMENT0);
return format->isColorFormat;
}
void
WebGLFBAttachPoint::SetImageDataStatus(WebGLImageDataStatus newStatus)
{
if (!HasImage())
return;
if (mRenderbufferPtr) {
mRenderbufferPtr->mImageDataStatus = newStatus;
return;
}
MOZ_ASSERT(mTexturePtr);
auto& imageInfo = mTexturePtr->ImageInfoAt(mTexImageTarget, mTexImageLevel);
MOZ_ASSERT(imageInfo.IsDefined());
const bool isDataInitialized = (newStatus == WebGLImageDataStatus::InitializedImageData);
imageInfo.SetIsDataInitialized(isDataInitialized, mTexturePtr);
}
//=======================================================================
//function : FillCompound
//purpose :
//=======================================================================
void GEOMAlgo_Gluer2::FillCompound(const TopoDS_Shape& aC)
{
Standard_Boolean bHasImage;
TopAbs_ShapeEnum aType;
TopoDS_Shape aCnew, aCXnew;
TopoDS_Iterator aItC;
BRep_Builder aBB;
//
bHasImage=HasImage(aC);
if (!bHasImage) {
return;
}
//
GEOMAlgo_Tools3D::MakeContainer(TopAbs_COMPOUND, aCnew);
//
aItC.Initialize(aC);
for (; aItC.More(); aItC.Next()) {
const TopoDS_Shape& aCX=aItC.Value();
aType=aCX.ShapeType();
//
if (aType==TopAbs_COMPOUND) {
FillCompound(aCX);
}
//
if (myOrigins.IsBound(aCX)) {
aCXnew=myOrigins.Find(aCX);
aCXnew.Orientation(aCX.Orientation());
aBB.Add(aCnew, aCXnew);
}
else {
aBB.Add(aCnew, aCX);
}
}
//
//myImages / myOrigins
TopTools_ListOfShape aLSD;
//
aLSD.Append(aC);
myImages.Bind(aCnew, aLSD);
myOrigins.Bind(aC, aCnew);
}
Mask2DCPtr ImageWidget::GetActiveMask() const
{
if(!HasImage())
throw std::runtime_error("GetActiveMask() called without image");
const bool
originalActive = _showOriginalMask && _originalMask != 0,
altActive = _showAlternativeMask && _alternativeMask != 0;
if(originalActive)
{
if(altActive)
{
Mask2DPtr mask = Mask2D::CreateCopy(_originalMask);
mask->Join(_alternativeMask);
return mask;
} else
return _originalMask;
} else {
if(altActive)
return _alternativeMask;
else
return Mask2D::CreateSetMaskPtr<false>(_image->Width(), _image->Height());
}
}
void
WebGLFBAttachPoint::FinalizeAttachment(gl::GLContext* gl, GLenum attachment) const
{
if (!HasImage()) {
switch (attachment) {
case LOCAL_GL_DEPTH_ATTACHMENT:
case LOCAL_GL_STENCIL_ATTACHMENT:
case LOCAL_GL_DEPTH_STENCIL_ATTACHMENT:
break;
default:
gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, attachment,
LOCAL_GL_RENDERBUFFER, 0);
break;
}
return;
}
MOZ_ASSERT(HasImage());
if (Texture()) {
MOZ_ASSERT(gl == Texture()->mContext->GL());
const GLenum imageTarget = ImageTarget().get();
const GLint mipLevel = MipLevel();
const GLint layer = Layer();
const GLuint glName = Texture()->mGLName;
switch (imageTarget) {
case LOCAL_GL_TEXTURE_2D:
case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
if (attachment == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_DEPTH_ATTACHMENT,
imageTarget, glName, mipLevel);
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
LOCAL_GL_STENCIL_ATTACHMENT, imageTarget,
glName, mipLevel);
} else {
gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, attachment, imageTarget,
glName, mipLevel);
}
break;
case LOCAL_GL_TEXTURE_2D_ARRAY:
case LOCAL_GL_TEXTURE_3D:
if (attachment == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
gl->fFramebufferTextureLayer(LOCAL_GL_FRAMEBUFFER,
LOCAL_GL_DEPTH_ATTACHMENT, glName, mipLevel,
layer);
gl->fFramebufferTextureLayer(LOCAL_GL_FRAMEBUFFER,
LOCAL_GL_STENCIL_ATTACHMENT, glName,
mipLevel, layer);
} else {
gl->fFramebufferTextureLayer(LOCAL_GL_FRAMEBUFFER, attachment, glName,
mipLevel, layer);
}
break;
}
return ;
}
if (Renderbuffer()) {
Renderbuffer()->FramebufferRenderbuffer(attachment);
return;
}
MOZ_CRASH();
}
