自学教程：C++ IsContextLost函数代码示例

voidWebGL2Context::ReadBuffer(GLenum mode){    if (IsContextLost())        return;    const bool isColorAttachment = (mode >= LOCAL_GL_COLOR_ATTACHMENT0 &&                                    mode <= LastColorAttachmentEnum());    if (mode != LOCAL_GL_NONE && mode != LOCAL_GL_BACK && !isColorAttachment) {        ErrorInvalidEnum("readBuffer: `mode` must be one of NONE, BACK, or "                         "COLOR_ATTACHMENTi. Was %s",                         EnumName(mode));        return;    }    if (mBoundReadFramebuffer) {        if (mode != LOCAL_GL_NONE &&            !isColorAttachment)        {            ErrorInvalidOperation("readBuffer: If READ_FRAMEBUFFER is non-null, `mode` "                                  "must be COLOR_ATTACHMENTi or NONE. Was %s",                                  EnumName(mode));            return;        }        MakeContextCurrent();        gl->fReadBuffer(mode);        return;    }    // Operating on the default framebuffer.    if (mode != LOCAL_GL_NONE &&        mode != LOCAL_GL_BACK)    {        ErrorInvalidOperation("readBuffer: If READ_FRAMEBUFFER is null, `mode`"                              " must be BACK or NONE. Was %s",                              EnumName(mode));        return;    }    gl->Screen()->SetReadBuffer(mode);}

voidWebGLContext::Enable(GLenum cap){    if (IsContextLost())        return;    if (!ValidateCapabilityEnum(cap, "enable"))        return;    realGLboolean* trackingSlot = GetStateTrackingSlot(cap);    if (trackingSlot)    {        *trackingSlot = 1;    }    MakeContextCurrent();    gl->fEnable(cap);}

voidWebGL2Context::EndQuery(GLenum target){    if (IsContextLost())        return;    if (!ValidateQueryTarget(target, "endQuery"))        return;    WebGLRefPtr<WebGLQuery>& querySlot = GetQuerySlotByTarget(target);    WebGLQuery* activeQuery = querySlot.get();    if (!activeQuery || target != activeQuery->mType)    {        /* From GLES's EXT_occlusion_query_boolean:         *     marks the end of the sequence of commands to be tracked for the         *     query type given by <target>. The active query object for         *     <target> is updated to indicate that query results are not         *     available, and the active query object name for <target> is reset         *     to zero. When the commands issued prior to EndQueryEXT have         *     completed and a final query result is available, the query object         *     active when EndQueryEXT is called is updated by the GL. The query         *     object is updated to indicate that the query results are         *     available and to contain the query result. If the active query         *     object name for <target> is zero when EndQueryEXT is called, the         *     error INVALID_OPERATION is generated.         */        ErrorInvalidOperation("endQuery: There is no active query of type %s.",                              GetQueryTargetEnumString(target));        return;    }    MakeContextCurrent();    if (target == LOCAL_GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN) {        gl->fEndQuery(LOCAL_GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);    } else {        gl->fEndQuery(SimulateOcclusionQueryTarget(gl, target));    }    UpdateBoundQuery(target, nullptr);    NS_DispatchToCurrentThread(new WebGLQuery::AvailableRunnable(activeQuery));}

voidWebGL2Context::GetInternalformatParameter(JSContext* cx, GLenum target,                                          GLenum internalformat, GLenum pname,                                          JS::MutableHandleValue retval,                                          ErrorResult& rv){  if (IsContextLost())    return;  if (target != LOCAL_GL_RENDERBUFFER) {    return ErrorInvalidEnumInfo("getInternalfomratParameter: target must be "                                "RENDERBUFFER. Was:", target);  }  // GL_INVALID_ENUM is generated if internalformat is not color-,  // depth-, or stencil-renderable.  // TODO: When format table queries lands.  if (pname != LOCAL_GL_SAMPLES) {    return ErrorInvalidEnumInfo("getInternalformatParameter: pname must be SAMPLES. "                                "Was:", pname);  }  GLint* samples = nullptr;  GLint sampleCount = 0;  gl->fGetInternalformativ(LOCAL_GL_RENDERBUFFER, internalformat,                           LOCAL_GL_NUM_SAMPLE_COUNTS, 1, &sampleCount);  if (sampleCount > 0) {    samples = new GLint[sampleCount];    gl->fGetInternalformativ(LOCAL_GL_RENDERBUFFER, internalformat, LOCAL_GL_SAMPLES,                             sampleCount, samples);  }  JSObject* obj = dom::Int32Array::Create(cx, this, sampleCount, samples);  if (!obj) {    rv = NS_ERROR_OUT_OF_MEMORY;  }  delete[] samples;  retval.setObjectOrNull(obj);}

voidWebGLContext::BufferDataT(GLenum target,                          const BufferT& data,                          GLenum usage){    if (IsContextLost())        return;    if (!ValidateBufferTarget(target, "bufferData"))        return;    const WebGLRefPtr<WebGLBuffer>& bufferSlot = GetBufferSlotByTarget(target);    data.ComputeLengthAndData();    // Careful: data.Length() could conceivably be any uint32_t, but GLsizeiptr    // is like intptr_t.    if (!CheckedInt<GLsizeiptr>(data.Length()).isValid())        return ErrorOutOfMemory("bufferData: bad size");    if (!ValidateBufferUsageEnum(usage, "bufferData: usage"))        return;    WebGLBuffer* boundBuffer = bufferSlot.get();    if (!boundBuffer)        return ErrorInvalidOperation("bufferData: no buffer bound!");    MakeContextCurrent();    InvalidateBufferFetching();    GLenum error = CheckedBufferData(target, data.Length(), data.Data(), usage);    if (error) {        GenerateWarning("bufferData generated error %s", ErrorName(error));        return;    }    boundBuffer->SetByteLength(data.Length());    if (!boundBuffer->ElementArrayCacheBufferData(data.Data(), data.Length()))        return ErrorOutOfMemory("bufferData: out of memory");}

voidWebGL2Context::BindSampler(GLuint unit, WebGLSampler* sampler){    if (IsContextLost())        return;    if (!ValidateObjectAllowDeletedOrNull("bindSampler", sampler))        return;    if (GLint(unit) >= mGLMaxTextureUnits)        return ErrorInvalidValue("bindSampler: unit must be < %d", mGLMaxTextureUnits);    if (sampler && sampler->IsDeleted())        return ErrorInvalidOperation("bindSampler: binding deleted sampler");    WebGLContextUnchecked::BindSampler(unit, sampler);    InvalidateResolveCacheForTextureWithTexUnit(unit);    mBoundSamplers[unit] = sampler;}

voidWebGL2Context::SamplerParameterfv(WebGLSampler* sampler, GLenum pname, const dom::Float32Array& param){    if (IsContextLost())        return;    if (!sampler || sampler->IsDeleted())        return ErrorInvalidOperation("samplerParameterfv: invalid sampler");    param.ComputeLengthAndData();    if (param.Length() < 1)        return /* TODO(djg): Error message */;    /* TODO(djg): All of these calls in ES3 only take 1 param */    if (!ValidateSamplerParameterParams(pname, WebGLIntOrFloat(param.Data()[0]), "samplerParameterfv"))        return;    sampler->SamplerParameter1f(pname, param.Data()[0]);    WebGLContextUnchecked::SamplerParameterfv(sampler, pname, param.Data());}

voidWebGLContext::EndQuery(GLenum target, const char* funcName){    if (!funcName) {        funcName = "endQuery";    }    if (IsContextLost())        return;    const auto& slot = ValidateQuerySlotByTarget(funcName, target);    if (!slot)        return;    const auto& query = *slot;    if (!query)        return ErrorInvalidOperation("%s: Query target not active.", funcName);    query->EndQuery();}

voidWebGL2Context::DeleteSampler(WebGLSampler* sampler){    if (IsContextLost())        return;    if (!ValidateObjectAllowDeletedOrNull("deleteSampler", sampler))        return;    if (!sampler || sampler->IsDeleted())        return;    for (int n = 0; n < mGLMaxTextureUnits; n++) {        if (mBoundSamplers[n] == sampler) {            mBoundSamplers[n] = nullptr;        }    }    sampler->RequestDelete();}

voidWebGL2Context::PauseTransformFeedback(){    if (IsContextLost())        return;    WebGLTransformFeedback* tf = mBoundTransformFeedback;    MOZ_ASSERT(tf);    if (!tf)        return;    if (!tf->mIsActive || tf->mIsPaused) {        return ErrorInvalidOperation("%s: transform feedback is not active or is paused",                                     "pauseTransformFeedback");    }    MakeContextCurrent();    gl->fPauseTransformFeedback();    tf->mIsPaused = true;}

voidWebGLContext::VertexAttribDivisor(GLuint index, GLuint divisor){    if (IsContextLost())        return;    if (!ValidateAttribIndex(index, "vertexAttribDivisor"))        return;    MOZ_ASSERT(mBoundVertexArray);    WebGLVertexAttribData& vd = mBoundVertexArray->mAttribs[index];    vd.mDivisor = divisor;    InvalidateBufferFetching();    MakeContextCurrent();    gl->fVertexAttribDivisor(index, divisor);}

/* This doesn't belong here. It's part of state querying */voidWebGL2Context::GetIndexedParameter(GLenum target, GLuint index,                                   dom::Nullable<dom::OwningWebGLBufferOrLongLong>& retval){    retval.SetNull();    if (IsContextLost())        return;    GLint64 data = 0;    MakeContextCurrent();    switch (target) {    case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:        if (index >= mGLMaxTransformFeedbackSeparateAttribs)            return ErrorInvalidValue("getIndexedParameter: index should be less than "                                     "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS");        retval.SetValue().SetAsWebGLBuffer() =            mBoundTransformFeedbackBuffers[index].get();        return;    case LOCAL_GL_UNIFORM_BUFFER_BINDING:        if (index >= mGLMaxUniformBufferBindings)            return ErrorInvalidValue("getIndexedParameter: index should be than "                                     "MAX_UNIFORM_BUFFER_BINDINGS");        retval.SetValue().SetAsWebGLBuffer() = mBoundUniformBuffers[index].get();        return;    case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_START:    case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:    case LOCAL_GL_UNIFORM_BUFFER_START:    case LOCAL_GL_UNIFORM_BUFFER_SIZE:        gl->fGetInteger64i_v(target, index, &data);        retval.SetValue().SetAsLongLong() = data;        return;    }    ErrorInvalidEnumInfo("getIndexedParameter: target", target);}

voidWebGL2Context::ClearBufferuiv(GLenum buffer, GLint drawBuffer, const Uint32Arr& src,                              GLuint srcElemOffset){    const char funcName[] = "clearBufferuiv";    if (IsContextLost())        return;    if (buffer != LOCAL_GL_COLOR)        return ErrorInvalidEnum("%s: buffer must be COLOR.", funcName);    if (!ValidateClearBuffer(funcName, buffer, drawBuffer, src.elemCount, srcElemOffset,                             LOCAL_GL_UNSIGNED_INT))    {        return;    }    ScopedDrawCallWrapper wrapper(*this);    const auto ptr = src.elemBytes + srcElemOffset;    gl->fClearBufferuiv(buffer, drawBuffer, ptr);}

voidWebGLContext::GetSupportedExtensions(dom::Nullable< nsTArray<nsString> >& retval,                                     dom::CallerType callerType){    retval.SetNull();    if (IsContextLost())        return;    nsTArray<nsString>& arr = retval.SetValue();    for (size_t i = 0; i < size_t(WebGLExtensionID::Max); i++) {        const auto extension = WebGLExtensionID(i);        if (extension == WebGLExtensionID::MOZ_debug)            continue; // Hide MOZ_debug from this list.        if (IsExtensionSupported(callerType, extension)) {            const char* extStr = GetExtensionString(extension);            arr.AppendElement(NS_ConvertUTF8toUTF16(extStr));        }    }}

voidWebGLContext::Clear(GLbitfield mask){    const char funcName[] = "clear";    if (IsContextLost())        return;    MakeContextCurrent();    uint32_t m = mask & (LOCAL_GL_COLOR_BUFFER_BIT | LOCAL_GL_DEPTH_BUFFER_BIT | LOCAL_GL_STENCIL_BUFFER_BIT);    if (mask != m)        return ErrorInvalidValue("%s: invalid mask bits", funcName);    if (mask == 0) {        GenerateWarning("Calling gl.clear(0) has no effect.");    } else if (mRasterizerDiscardEnabled) {        GenerateWarning("Calling gl.clear() with RASTERIZER_DISCARD enabled has no effects.");    }    if (mBoundDrawFramebuffer) {        if (!mBoundDrawFramebuffer->ValidateAndInitAttachments(funcName))            return;        gl->fClear(mask);        return;    } else {        ClearBackbufferIfNeeded();    }    // Ok, we're clearing the default framebuffer/screen.    {        ScopedMaskWorkaround autoMask(*this);        gl->fClear(mask);    }    Invalidate();    mShouldPresent = true;}

voidWebGLContext::BindBufferRange(GLenum target, GLuint index, WebGLBuffer* buffer,                              WebGLintptr offset, WebGLsizeiptr size){    if (IsContextLost())        return;    if (!ValidateObjectAllowDeletedOrNull("bindBufferRange", buffer))        return;    // silently ignore a deleted buffer    if (buffer && buffer->IsDeleted())        return;    // ValidateBufferTarget    switch (target) {    case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER:        if (index >= mGLMaxTransformFeedbackSeparateAttribs)            return ErrorInvalidValue("bindBufferRange: index should be less than "                                     "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS");        break;    case LOCAL_GL_UNIFORM_BUFFER:        if (index >= mGLMaxUniformBufferBindings)            return ErrorInvalidValue("bindBufferRange: index should be less than "                                     "MAX_UNIFORM_BUFFER_BINDINGS");        break;    default:        return ErrorInvalidEnumInfo("bindBufferRange: target", target);    }    if (!ValidateBufferForTarget(target, buffer, "bindBufferRange"))        return;    WebGLContextUnchecked::BindBufferRange(target, index, buffer, offset, size);    UpdateBoundBufferIndexed(target, index, buffer);}

already_AddRefed<WebGLQuery>WebGL2Context::GetQuery(GLenum target, GLenum pname){    if (IsContextLost())        return nullptr;    if (!ValidateQueryTarget(target, "getQuery"))        return nullptr;    if (pname != LOCAL_GL_CURRENT_QUERY) {        /* OpenGL ES 3.0 spec 6.1.7:         *     pname must be CURRENT_QUERY.         */        ErrorInvalidEnum("getQuery: `pname` must be CURRENT_QUERY.");        return nullptr;    }    WebGLRefPtr<WebGLQuery>& targetSlot = GetQuerySlotByTarget(target);    nsRefPtr<WebGLQuery> tmp = targetSlot.get();    return tmp.forget();}

already_AddRefed<WebGLSampler>WebGL2Context::CreateSampler(){    const char funcName[] = "createSampler";    if (IsContextLost())        return nullptr;    /*    GLuint sampler;    MakeContextCurrent();    gl->fGenSamplers(1, &sampler);    RefPtr<WebGLSampler> globj = new WebGLSampler(this, sampler);    return globj.forget();    */    ErrorInvalidOperation("%s: Sampler objects are still under development, and are"                          " currently disabled.",                          funcName);    return nullptr;}

voidWebGLContext::DrawBuffers(const dom::Sequence<GLenum>& buffers){    const char funcName[] = "drawBuffers";    if (IsContextLost())        return;    if (mBoundDrawFramebuffer) {        mBoundDrawFramebuffer->DrawBuffers(funcName, buffers);        return;    }    // GLES 3.0.4 p186:    // "If the GL is bound to the default framebuffer, then `n` must be 1 and the    //  constant must be BACK or NONE. [...] If DrawBuffers is supplied with a    //  constant other than BACK and NONE, or with a value of `n` other than 1, the    //  error INVALID_OPERATION is generated."    if (buffers.Length() != 1) {        ErrorInvalidOperation("%s: For the default framebuffer, `buffers` must have a"                              " length of 1.",                              funcName);        return;    }    switch (buffers[0]) {    case LOCAL_GL_NONE:    case LOCAL_GL_BACK:        break;    default:        ErrorInvalidOperation("%s: For the default framebuffer, `buffers[0]` must be"                              " BACK or NONE.",                              funcName);        return;    }    mDefaultFB_DrawBuffer0 = buffers[0];    gl->Screen()->SetDrawBuffer(buffers[0]);}

voidWebGLContext::DrawElements(GLenum mode, GLsizei count, GLenum type,                           WebGLintptr byteOffset){    const char funcName[] = "drawElements";    if (IsContextLost())        return;    if (!ValidateDrawModeEnum(mode, funcName))        return;    MakeContextCurrent();    bool error;    ScopedResolveTexturesForDraw scopedResolve(this, funcName, &error);    if (error)        return;    GLuint upperBound = 0;    if (!DrawElements_check(count, type, byteOffset, 1, funcName, &upperBound))        return;    RunContextLossTimer();    {        ScopedMaskWorkaround autoMask(*this);        if (gl->IsSupported(gl::GLFeature::draw_range_elements)) {            gl->fDrawRangeElements(mode, 0, upperBound, count, type,                                   reinterpret_cast<GLvoid*>(byteOffset));        } else {            gl->fDrawElements(mode, count, type,                              reinterpret_cast<GLvoid*>(byteOffset));        }    }    Draw_cleanup(funcName);}

voidWebGLContext::BindBuffer(GLenum target, WebGLBuffer* buffer){    if (IsContextLost())        return;    if (!ValidateObjectAllowDeletedOrNull("bindBuffer", buffer))        return;    // silently ignore a deleted buffer    if (buffer && buffer->IsDeleted())        return;    if (!ValidateBufferTarget(target, "bindBuffer"))        return;    if (!ValidateBufferForTarget(target, buffer, "bindBuffer"))        return;    WebGLContextUnchecked::BindBuffer(target, buffer);    UpdateBoundBuffer(target, buffer);}

voidWebGL2Context::BindTransformFeedback(GLenum target, WebGLTransformFeedback* tf){    const char funcName[] = "bindTransformFeedback";    if (IsContextLost())        return;    if (target != LOCAL_GL_TRANSFORM_FEEDBACK)        return ErrorInvalidEnum("%s: `target` must be TRANSFORM_FEEDBACK.", funcName);    if (tf && !ValidateObject(funcName, *tf))        return;    if (mBoundTransformFeedback->mIsActive &&        !mBoundTransformFeedback->mIsPaused)    {        ErrorInvalidOperation("%s: Currently bound transform feedback is active and not"                              " paused.",                              funcName);        return;    }    ////    if (mBoundTransformFeedback) {        mBoundTransformFeedback->AddBufferBindCounts(-1);    }    mBoundTransformFeedback = (tf ? tf : mDefaultTransformFeedback);    MakeContextCurrent();    gl->fBindTransformFeedback(target, mBoundTransformFeedback->mGLName);    if (mBoundTransformFeedback) {        mBoundTransformFeedback->AddBufferBindCounts(+1);    }}

voidWebGLContext::ClearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a){    if (IsContextLost())        return;    MakeContextCurrent();    const bool supportsFloatColorBuffers = (IsExtensionEnabled(WebGLExtensionID::EXT_color_buffer_half_float) ||                                            IsExtensionEnabled(WebGLExtensionID::WEBGL_color_buffer_float));    if (!supportsFloatColorBuffers) {        r = GLClampFloat(r);        g = GLClampFloat(g);        b = GLClampFloat(b);        a = GLClampFloat(a);    }    gl->fClearColor(r, g, b, a);    mColorClearValue[0] = r;    mColorClearValue[1] = g;    mColorClearValue[2] = b;    mColorClearValue[3] = a;}

voidWebGL2Context::CopyBufferSubData(GLenum readTarget, GLenum writeTarget,                                 GLintptr readOffset, GLintptr writeOffset,                                 GLsizeiptr size){    if (IsContextLost())        return;    if (!ValidateBufferTarget(readTarget, "copyBufferSubData") ||            !ValidateBufferTarget(writeTarget, "copyBufferSubData"))    {        return;    }    const WebGLRefPtr<WebGLBuffer>& readBufferSlot = GetBufferSlotByTarget(readTarget);    const WebGLRefPtr<WebGLBuffer>& writeBufferSlot = GetBufferSlotByTarget(writeTarget);    if (!readBufferSlot || !writeBufferSlot)        return;    const WebGLBuffer* readBuffer = readBufferSlot.get();    if (!readBuffer)        return ErrorInvalidOperation("copyBufferSubData: No buffer bound to readTarget");    WebGLBuffer* writeBuffer = writeBufferSlot.get();    if (!writeBuffer)        return ErrorInvalidOperation("copyBufferSubData: No buffer bound to writeTarget");    if (!ValidateDataOffsetSize(readOffset, size, readBuffer->ByteLength(),                                "copyBufferSubData"))    {        return;    }    if (!ValidateDataOffsetSize(writeOffset, size, writeBuffer->ByteLength(),                                "copyBufferSubData"))    {        return;    }    if (readTarget == writeTarget &&            !ValidateDataRanges(readOffset, writeOffset, size, "copyBufferSubData"))    {        return;    }    WebGLBuffer::Kind readType = readBuffer->Content();    WebGLBuffer::Kind writeType = writeBuffer->Content();    if (readType != WebGLBuffer::Kind::Undefined &&            writeType != WebGLBuffer::Kind::Undefined &&            writeType != readType)    {        ErrorInvalidOperation("copyBufferSubData: Can't copy %s data to %s data",                              (readType == WebGLBuffer::Kind::OtherData) ? "other" : "element",                              (writeType == WebGLBuffer::Kind::OtherData) ? "other" : "element");        return;    }    WebGLContextUnchecked::CopyBufferSubData(readTarget, writeTarget, readOffset,            writeOffset, size);    if (writeType == WebGLBuffer::Kind::Undefined) {        writeBuffer->BindTo(            (readType == WebGLBuffer::Kind::OtherData) ? LOCAL_GL_ARRAY_BUFFER            : LOCAL_GL_ELEMENT_ARRAY_BUFFER);    }}

voidWebGL2Context::GetActiveUniforms(JSContext* cx, const WebGLProgram& program,                                 const dom::Sequence<GLuint>& uniformIndices,                                 GLenum pname, JS::MutableHandleValue retval){    const char funcName[] = "getActiveUniforms";    retval.setNull();    if (IsContextLost())        return;    if (!ValidateUniformEnum(this, pname, funcName))        return;    if (!ValidateObject("getActiveUniforms: program", program))        return;    const auto& numActiveUniforms = program.LinkInfo()->uniforms.size();    for (const auto& curIndex : uniformIndices) {        if (curIndex >= numActiveUniforms) {            ErrorInvalidValue("%s: Too-large active uniform index queried.", funcName);            return;        }    }    const auto& count = uniformIndices.Length();    JS::Rooted<JSObject*> array(cx, JS_NewArrayObject(cx, count));    UniquePtr<GLint[]> samples(new GLint[count]);    if (!array || !samples) {        ErrorOutOfMemory("%s: Failed to allocate buffers.", funcName);        return;    }    retval.setObject(*array);    MakeContextCurrent();    gl->fGetActiveUniformsiv(program.mGLName, count, uniformIndices.Elements(), pname,                             samples.get());    switch (pname) {    case LOCAL_GL_UNIFORM_TYPE:    case LOCAL_GL_UNIFORM_SIZE:    case LOCAL_GL_UNIFORM_BLOCK_INDEX:    case LOCAL_GL_UNIFORM_OFFSET:    case LOCAL_GL_UNIFORM_ARRAY_STRIDE:    case LOCAL_GL_UNIFORM_MATRIX_STRIDE:        for (size_t i = 0; i < count; ++i) {            JS::RootedValue value(cx);            value = JS::Int32Value(samples[i]);            if (!JS_DefineElement(cx, array, i, value, JSPROP_ENUMERATE))                return;        }        break;    case LOCAL_GL_UNIFORM_IS_ROW_MAJOR:        for (size_t i = 0; i < count; ++i) {            JS::RootedValue value(cx);            value = JS::BooleanValue(samples[i]);            if (!JS_DefineElement(cx, array, i, value, JSPROP_ENUMERATE))                return;        }        break;    default:        MOZ_CRASH("Invalid pname");    }}