ContextNULL.cpp | Explore in Territory

//
// Copyright 2016 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// ContextNULL.cpp:
//    Implements the class methods for ContextNULL.
//

#include "libANGLE/renderer/null/ContextNULL.h"

#include "common/debug.h"

#include "libANGLE/Context.h"
#include "libANGLE/renderer/OverlayImpl.h"
#include "libANGLE/renderer/null/BufferNULL.h"
#include "libANGLE/renderer/null/CompilerNULL.h"
#include "libANGLE/renderer/null/DisplayNULL.h"
#include "libANGLE/renderer/null/FenceNVNULL.h"
#include "libANGLE/renderer/null/FramebufferNULL.h"
#include "libANGLE/renderer/null/ImageNULL.h"
#include "libANGLE/renderer/null/ProgramExecutableNULL.h"
#include "libANGLE/renderer/null/ProgramNULL.h"
#include "libANGLE/renderer/null/ProgramPipelineNULL.h"
#include "libANGLE/renderer/null/QueryNULL.h"
#include "libANGLE/renderer/null/RenderbufferNULL.h"
#include "libANGLE/renderer/null/SamplerNULL.h"
#include "libANGLE/renderer/null/ShaderNULL.h"
#include "libANGLE/renderer/null/SyncNULL.h"
#include "libANGLE/renderer/null/TextureNULL.h"
#include "libANGLE/renderer/null/TransformFeedbackNULL.h"
#include "libANGLE/renderer/null/VertexArrayNULL.h"

namespace rx
{

AllocationTrackerNULL::AllocationTrackerNULL(size_t maxTotalAllocationSize)
    : … { … }

AllocationTrackerNULL::~AllocationTrackerNULL()
{ … }

bool AllocationTrackerNULL::updateMemoryAllocation(size_t oldSize, size_t newSize)
{ … }

ContextNULL::ContextNULL(const gl::State &state,
                         gl::ErrorSet *errorSet,
                         AllocationTrackerNULL *allocationTracker)
    : … { … }

ContextNULL::~ContextNULL() { … }

angle::Result ContextNULL::initialize(const angle::ImageLoadContext &imageLoadContext)
{ … }

angle::Result ContextNULL::flush(const gl::Context *context)
{ … }

angle::Result ContextNULL::finish(const gl::Context *context)
{ … }

angle::Result ContextNULL::drawArrays(const gl::Context *context,
                                      gl::PrimitiveMode mode,
                                      GLint first,
                                      GLsizei count)
{ … }

angle::Result ContextNULL::drawArraysInstanced(const gl::Context *context,
                                               gl::PrimitiveMode mode,
                                               GLint first,
                                               GLsizei count,
                                               GLsizei instanceCount)
{ … }

angle::Result ContextNULL::drawArraysInstancedBaseInstance(const gl::Context *context,
                                                           gl::PrimitiveMode mode,
                                                           GLint first,
                                                           GLsizei count,
                                                           GLsizei instanceCount,
                                                           GLuint baseInstance)
{ … }

angle::Result ContextNULL::drawElements(const gl::Context *context,
                                        gl::PrimitiveMode mode,
                                        GLsizei count,
                                        gl::DrawElementsType type,
                                        const void *indices)
{ … }

angle::Result ContextNULL::drawElementsBaseVertex(const gl::Context *context,
                                                  gl::PrimitiveMode mode,
                                                  GLsizei count,
                                                  gl::DrawElementsType type,
                                                  const void *indices,
                                                  GLint baseVertex)
{ … }

angle::Result ContextNULL::drawElementsInstanced(const gl::Context *context,
                                                 gl::PrimitiveMode mode,
                                                 GLsizei count,
                                                 gl::DrawElementsType type,
                                                 const void *indices,
                                                 GLsizei instances)
{ … }

angle::Result ContextNULL::drawElementsInstancedBaseVertex(const gl::Context *context,
                                                           gl::PrimitiveMode mode,
                                                           GLsizei count,
                                                           gl::DrawElementsType type,
                                                           const void *indices,
                                                           GLsizei instances,
                                                           GLint baseVertex)
{ … }

angle::Result ContextNULL::drawElementsInstancedBaseVertexBaseInstance(const gl::Context *context,
                                                                       gl::PrimitiveMode mode,
                                                                       GLsizei count,
                                                                       gl::DrawElementsType type,
                                                                       const void *indices,
                                                                       GLsizei instances,
                                                                       GLint baseVertex,
                                                                       GLuint baseInstance)
{ … }

angle::Result ContextNULL::drawRangeElements(const gl::Context *context,
                                             gl::PrimitiveMode mode,
                                             GLuint start,
                                             GLuint end,
                                             GLsizei count,
                                             gl::DrawElementsType type,
                                             const void *indices)
{ … }

angle::Result ContextNULL::drawRangeElementsBaseVertex(const gl::Context *context,
                                                       gl::PrimitiveMode mode,
                                                       GLuint start,
                                                       GLuint end,
                                                       GLsizei count,
                                                       gl::DrawElementsType type,
                                                       const void *indices,
                                                       GLint baseVertex)
{ … }

angle::Result ContextNULL::drawArraysIndirect(const gl::Context *context,
                                              gl::PrimitiveMode mode,
                                              const void *indirect)
{ … }

angle::Result ContextNULL::drawElementsIndirect(const gl::Context *context,
                                                gl::PrimitiveMode mode,
                                                gl::DrawElementsType type,
                                                const void *indirect)
{ … }

angle::Result ContextNULL::multiDrawArrays(const gl::Context *context,
                                           gl::PrimitiveMode mode,
                                           const GLint *firsts,
                                           const GLsizei *counts,
                                           GLsizei drawcount)
{ … }

angle::Result ContextNULL::multiDrawArraysInstanced(const gl::Context *context,
                                                    gl::PrimitiveMode mode,
                                                    const GLint *firsts,
                                                    const GLsizei *counts,
                                                    const GLsizei *instanceCounts,
                                                    GLsizei drawcount)
{ … }

angle::Result ContextNULL::multiDrawArraysIndirect(const gl::Context *context,
                                                   gl::PrimitiveMode mode,
                                                   const void *indirect,
                                                   GLsizei drawcount,
                                                   GLsizei stride)
{ … }

angle::Result ContextNULL::multiDrawElements(const gl::Context *context,
                                             gl::PrimitiveMode mode,
                                             const GLsizei *counts,
                                             gl::DrawElementsType type,
                                             const GLvoid *const *indices,
                                             GLsizei drawcount)
{ … }

angle::Result ContextNULL::multiDrawElementsInstanced(const gl::Context *context,
                                                      gl::PrimitiveMode mode,
                                                      const GLsizei *counts,
                                                      gl::DrawElementsType type,
                                                      const GLvoid *const *indices,
                                                      const GLsizei *instanceCounts,
                                                      GLsizei drawcount)
{ … }

angle::Result ContextNULL::multiDrawElementsIndirect(const gl::Context *context,
                                                     gl::PrimitiveMode mode,
                                                     gl::DrawElementsType type,
                                                     const void *indirect,
                                                     GLsizei drawcount,
                                                     GLsizei stride)
{ … }

angle::Result ContextNULL::multiDrawArraysInstancedBaseInstance(const gl::Context *context,
                                                                gl::PrimitiveMode mode,
                                                                const GLint *firsts,
                                                                const GLsizei *counts,
                                                                const GLsizei *instanceCounts,
                                                                const GLuint *baseInstances,
                                                                GLsizei drawcount)
{ … }

angle::Result ContextNULL::multiDrawElementsInstancedBaseVertexBaseInstance(
    const gl::Context *context,
    gl::PrimitiveMode mode,
    const GLsizei *counts,
    gl::DrawElementsType type,
    const GLvoid *const *indices,
    const GLsizei *instanceCounts,
    const GLint *baseVertices,
    const GLuint *baseInstances,
    GLsizei drawcount)
{ … }

gl::GraphicsResetStatus ContextNULL::getResetStatus()
{ … }

angle::Result ContextNULL::insertEventMarker(GLsizei length, const char *marker)
{ … }

angle::Result ContextNULL::pushGroupMarker(GLsizei length, const char *marker)
{ … }

angle::Result ContextNULL::popGroupMarker()
{ … }

angle::Result ContextNULL::pushDebugGroup(const gl::Context *context,
                                          GLenum source,
                                          GLuint id,
                                          const std::string &message)
{ … }

angle::Result ContextNULL::popDebugGroup(const gl::Context *context)
{ … }

angle::Result ContextNULL::syncState(const gl::Context *context,
                                     const gl::state::DirtyBits dirtyBits,
                                     const gl::state::DirtyBits bitMask,
                                     const gl::state::ExtendedDirtyBits extendedDirtyBits,
                                     const gl::state::ExtendedDirtyBits extendedBitMask,
                                     gl::Command command)
{ … }

GLint ContextNULL::getGPUDisjoint()
{ … }

GLint64 ContextNULL::getTimestamp()
{ … }

angle::Result ContextNULL::onMakeCurrent(const gl::Context *context)
{ … }

gl::Caps ContextNULL::getNativeCaps() const
{ … }

const gl::TextureCapsMap &ContextNULL::getNativeTextureCaps() const
{ … }

const gl::Extensions &ContextNULL::getNativeExtensions() const
{ … }

const gl::Limitations &ContextNULL::getNativeLimitations() const
{ … }

const ShPixelLocalStorageOptions &ContextNULL::getNativePixelLocalStorageOptions() const
{ … }

CompilerImpl *ContextNULL::createCompiler()
{ … }

ShaderImpl *ContextNULL::createShader(const gl::ShaderState &data)
{ … }

ProgramImpl *ContextNULL::createProgram(const gl::ProgramState &data)
{ … }

ProgramExecutableImpl *ContextNULL::createProgramExecutable(const gl::ProgramExecutable *executable)
{ … }

FramebufferImpl *ContextNULL::createFramebuffer(const gl::FramebufferState &data)
{ … }

TextureImpl *ContextNULL::createTexture(const gl::TextureState &state)
{ … }

RenderbufferImpl *ContextNULL::createRenderbuffer(const gl::RenderbufferState &state)
{ … }

BufferImpl *ContextNULL::createBuffer(const gl::BufferState &state)
{ … }

VertexArrayImpl *ContextNULL::createVertexArray(const gl::VertexArrayState &data)
{ … }

QueryImpl *ContextNULL::createQuery(gl::QueryType type)
{ … }

FenceNVImpl *ContextNULL::createFenceNV()
{ … }

SyncImpl *ContextNULL::createSync()
{ … }

TransformFeedbackImpl *ContextNULL::createTransformFeedback(const gl::TransformFeedbackState &state)
{ … }

SamplerImpl *ContextNULL::createSampler(const gl::SamplerState &state)
{ … }

ProgramPipelineImpl *ContextNULL::createProgramPipeline(const gl::ProgramPipelineState &state)
{ … }

MemoryObjectImpl *ContextNULL::createMemoryObject()
{ … }

SemaphoreImpl *ContextNULL::createSemaphore()
{ … }

OverlayImpl *ContextNULL::createOverlay(const gl::OverlayState &state)
{ … }

angle::Result ContextNULL::dispatchCompute(const gl::Context *context,
                                           GLuint numGroupsX,
                                           GLuint numGroupsY,
                                           GLuint numGroupsZ)
{ … }

angle::Result ContextNULL::dispatchComputeIndirect(const gl::Context *context, GLintptr indirect)
{ … }

angle::Result ContextNULL::memoryBarrier(const gl::Context *context, GLbitfield barriers)
{ … }

angle::Result ContextNULL::memoryBarrierByRegion(const gl::Context *context, GLbitfield barriers)
{ … }

void ContextNULL::handleError(GLenum errorCode,
                              const char *message,
                              const char *file,
                              const char *function,
                              unsigned int line)
{ … }
}  // namespace rx
chromium/third_party/angle/src/libANGLE/renderer/null/ContextNULL.cpp
