Skip to content

S
swiftshader
Commit 45be1bc3 by Nicolas Capens Committed by Nicolas Capens
Options

Eliminate the OpenGL ES 1.1 implementation

SwiftShader's OpenGL ES support is deprecated in favor of the Vulkan implementation, with ANGLE providing backward compatibility for GLES use cases. There are no known uses of our OpenGL ES 1.1 implementation left, so this change removes its code entirely. Bug: b/147516027 Change-Id: I72bcd7a648df435bd5c00caf3b4bb35965a0c116 Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/53909 Kokoro-Result: kokoro <noreply+kokoro@google.com> Tested-by: 's avatarNicolas Capens <nicolascapens@google.com> Reviewed-by: 's avatarAlexis Hétu <sugoi@google.com>
parent 77edad29
Showing with 33 additions and 3216 deletions
src/OpenGL/libEGL/Config.cpp
...@@ -26,11 +26,11 @@ ...@@ -26,11 +26,11 @@
#include <system/graphics.h> #include <system/graphics.h>
#endif #endif
#include <string.h>
#include <algorithm> #include <algorithm>
#include <cstring> #include <cstring>
#include <vector>
#include <map> #include <map>
#include <string.h>
#include <vector>
using namespace std; using namespace std;
...@@ -123,7 +123,7 @@ Config::Config(sw::Format displayFormat, EGLint minInterval, EGLint maxInterval, ...@@ -123,7 +123,7 @@ Config::Config(sw::Format displayFormat, EGLint minInterval, EGLint maxInterval,
mColorBufferType = EGL_RGB_BUFFER; mColorBufferType = EGL_RGB_BUFFER;
mConfigCaveat = EGL_NONE; mConfigCaveat = EGL_NONE;
mConfigID = 0; mConfigID = 0;
mConformant = EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT; mConformant = EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT;
switch(depthStencilFormat) switch(depthStencilFormat)
{ {
...@@ -180,7 +180,7 @@ Config::Config(sw::Format displayFormat, EGLint minInterval, EGLint maxInterval, ...@@ -180,7 +180,7 @@ Config::Config(sw::Format displayFormat, EGLint minInterval, EGLint maxInterval,
mMinSwapInterval = minInterval; mMinSwapInterval = minInterval;
mNativeRenderable = EGL_FALSE; mNativeRenderable = EGL_FALSE;
mNativeVisualType = 0; mNativeVisualType = 0;
mRenderableType = EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT; mRenderableType = EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT;
mSampleBuffers = (multiSample > 0) ? 1 : 0; mSampleBuffers = (multiSample > 0) ? 1 : 0;
mSamples = multiSample; mSamples = multiSample;
mSurfaceType = EGL_PBUFFER_BIT | EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT | EGL_MULTISAMPLE_RESOLVE_BOX_BIT; mSurfaceType = EGL_PBUFFER_BIT | EGL_WINDOW_BIT | EGL_SWAP_BEHAVIOR_PRESERVED_BIT | EGL_MULTISAMPLE_RESOLVE_BOX_BIT;
......
src/OpenGL/libEGL/Display.cpp
...@@ -18,18 +18,18 @@ ...@@ -18,18 +18,18 @@
#include "Display.h" #include "Display.h"
#include "main.h" #include "Common/RecursiveLock.hpp"
#include "libEGL/Surface.hpp"
#include "libEGL/Context.hpp"
#include "common/Image.hpp" #include "common/Image.hpp"
#include "common/debug.h" #include "common/debug.h"
#include "Common/RecursiveLock.hpp" #include "libEGL/Context.hpp"
#include "libEGL/Surface.hpp"
#include "main.h"
#if defined(__ANDROID__) && !defined(ANDROID_NDK_BUILD) #if defined(__ANDROID__) && !defined(ANDROID_NDK_BUILD)
#include <vndk/window.h>
#include <sys/ioctl.h>
#include <linux/fb.h>
#include <fcntl.h> #include <fcntl.h>
#include <linux/fb.h>
#include <sys/ioctl.h>
#include <vndk/window.h>
#elif defined(USE_X11) #elif defined(USE_X11)
#include "Main/libX11.hpp" #include "Main/libX11.hpp"
#elif defined(__APPLE__) #elif defined(__APPLE__)
...@@ -39,8 +39,8 @@ ...@@ -39,8 +39,8 @@
#endif #endif
#include <algorithm> #include <algorithm>
#include <vector>
#include <map> #include <map>
#include <vector>
namespace egl namespace egl
{ {
...@@ -569,14 +569,7 @@ EGLContext Display::createContext(EGLConfig configHandle, const egl::Context *sh ...@@ -569,14 +569,7 @@ EGLContext Display::createContext(EGLConfig configHandle, const egl::Context *sh
const egl::Config *config = mConfigSet.get(configHandle); const egl::Config *config = mConfigSet.get(configHandle);
egl::Context *context = nullptr; egl::Context *context = nullptr;
if(clientVersion == 1 && config->mRenderableType & EGL_OPENGL_ES_BIT) if((clientVersion == 2 && config->mRenderableType & EGL_OPENGL_ES2_BIT) ||
{
if(libGLES_CM)
{
context = libGLES_CM->es1CreateContext(this, shareContext, config);
}
}
else if((clientVersion == 2 && config->mRenderableType & EGL_OPENGL_ES2_BIT) ||
(clientVersion == 3 && config->mRenderableType & EGL_OPENGL_ES3_BIT)) (clientVersion == 3 && config->mRenderableType & EGL_OPENGL_ES3_BIT))
{ {
if(libGLESv2) if(libGLESv2)
......
src/OpenGL/libEGL/Surface.cpp
...@@ -18,13 +18,13 @@ ...@@ -18,13 +18,13 @@
#include "Surface.hpp" #include "Surface.hpp"
#include "main.h" #include "Context.hpp"
#include "Display.h" #include "Display.h"
#include "Main/FrameBuffer.hpp"
#include "Texture.hpp" #include "Texture.hpp"
#include "common/Image.hpp" #include "common/Image.hpp"
#include "Context.hpp"
#include "common/debug.h" #include "common/debug.h"
#include "Main/FrameBuffer.hpp" #include "main.h"
#if defined(USE_X11) #if defined(USE_X11)
#include "Main/libX11.hpp" #include "Main/libX11.hpp"
...@@ -77,10 +77,6 @@ bool Surface::initialize() ...@@ -77,10 +77,6 @@ bool Surface::initialize()
backBuffer = libGLESv2->createBackBuffer(width, height, config->mRenderTargetFormat, config->mSamples); backBuffer = libGLESv2->createBackBuffer(width, height, config->mRenderTargetFormat, config->mSamples);
} }
} }
else if(libGLES_CM)
{
backBuffer = libGLES_CM->createBackBuffer(width, height, config->mRenderTargetFormat, config->mSamples);
}
if(!backBuffer) if(!backBuffer)
{ {
...@@ -95,10 +91,6 @@ bool Surface::initialize() ...@@ -95,10 +91,6 @@ bool Surface::initialize()
{ {
depthStencil = libGLESv2->createDepthStencil(width, height, config->mDepthStencilFormat, config->mSamples); depthStencil = libGLESv2->createDepthStencil(width, height, config->mDepthStencilFormat, config->mSamples);
} }
else if(libGLES_CM)
{
depthStencil = libGLES_CM->createDepthStencil(width, height, config->mDepthStencilFormat, config->mSamples);
}
if(!depthStencil) if(!depthStencil)
{ {
...@@ -409,10 +401,6 @@ bool WindowSurface::reset(int backBufferWidth, int backBufferHeight) ...@@ -409,10 +401,6 @@ bool WindowSurface::reset(int backBufferWidth, int backBufferHeight)
{ {
frameBuffer = libGLESv2->createFrameBuffer(display->getNativeDisplay(), window, width, height); frameBuffer = libGLESv2->createFrameBuffer(display->getNativeDisplay(), window, width, height);
} }
else if(libGLES_CM)
{
frameBuffer = libGLES_CM->createFrameBuffer(display->getNativeDisplay(), window, width, height);
}
if(!frameBuffer) if(!frameBuffer)
{ {
......
src/OpenGL/libEGL/libEGL.cpp
...@@ -14,14 +14,14 @@ ...@@ -14,14 +14,14 @@
// libEGL.cpp: Implements the exported EGL functions. // libEGL.cpp: Implements the exported EGL functions.
#include "main.h" #include "Common/Version.h"
#include "Context.hpp"
#include "Display.h" #include "Display.h"
#include "Surface.hpp" #include "Surface.hpp"
#include "Texture.hpp" #include "Texture.hpp"
#include "Context.hpp"
#include "common/Image.hpp" #include "common/Image.hpp"
#include "common/debug.h" #include "common/debug.h"
#include "Common/Version.h" #include "main.h"
#if defined(__ANDROID__) && !defined(ANDROID_NDK_BUILD) #if defined(__ANDROID__) && !defined(ANDROID_NDK_BUILD)
#include <vndk/window.h> #include <vndk/window.h>
...@@ -30,8 +30,8 @@ ...@@ -30,8 +30,8 @@
#endif #endif
#include <algorithm> #include <algorithm>
#include <vector>
#include <string.h> #include <string.h>
#include <vector>
namespace egl namespace egl
{ {
...@@ -1615,12 +1615,6 @@ __eglMustCastToProperFunctionPointerType EGLAPIENTRY GetProcAddress(const char * ...@@ -1615,12 +1615,6 @@ __eglMustCastToProperFunctionPointerType EGLAPIENTRY GetProcAddress(const char *
if(proc) return success(proc); if(proc) return success(proc);
} }
if(libGLES_CM)
{
__eglMustCastToProperFunctionPointerType proc = libGLES_CM->es1GetProcAddress(procname);
if(proc) return success(proc);
}
return success((__eglMustCastToProperFunctionPointerType)NULL); return success((__eglMustCastToProperFunctionPointerType)NULL);
} }
} }
src/OpenGL/libEGL/main.cpp
...@@ -16,15 +16,15 @@ ...@@ -16,15 +16,15 @@
#include "main.h" #include "main.h"
#include "libEGL.hpp"
#include "Context.hpp" #include "Context.hpp"
#include "Surface.hpp"
#include "Display.h" #include "Display.h"
#include "Surface.hpp"
#include "libEGL.hpp"
#include "resource.h"
#include "Common/Thread.hpp"
#include "Common/SharedLibrary.hpp" #include "Common/SharedLibrary.hpp"
#include "Common/Thread.hpp"
#include "common/debug.h" #include "common/debug.h"
#include "resource.h"
#include <EGL/eglext.h> #include <EGL/eglext.h>
...@@ -720,5 +720,4 @@ extern "C" EGLAPI LibEGLexports *libEGL_swiftshader() ...@@ -720,5 +720,4 @@ extern "C" EGLAPI LibEGLexports *libEGL_swiftshader()
return &libEGL; return &libEGL;
} }
LibGLES_CM libGLES_CM;
LibGLESv2 libGLESv2; LibGLESv2 libGLESv2;
src/OpenGL/libEGL/main.h
...@@ -17,7 +17,6 @@ ...@@ -17,7 +17,6 @@
#ifndef LIBEGL_MAIN_H_ #ifndef LIBEGL_MAIN_H_
#define LIBEGL_MAIN_H_ #define LIBEGL_MAIN_H_
#include "libGLES_CM/libGLES_CM.hpp"
#include "libGLESv2/libGLESv2.hpp" #include "libGLESv2/libGLESv2.hpp"
#include <EGL/egl.h> #include <EGL/egl.h>
...@@ -76,7 +75,6 @@ namespace egl ...@@ -76,7 +75,6 @@ namespace egl
} }
} }
extern LibGLES_CM libGLES_CM;
extern LibGLESv2 libGLESv2; extern LibGLESv2 libGLESv2;
#endif // LIBEGL_MAIN_H_ #endif // LIBEGL_MAIN_H_
src/OpenGL/libGLES_CM/Buffer.cpp deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Buffer.cpp: Implements the Buffer class, representing storage of vertex and/or
// index data. Implements GL buffer objects and related functionality.
// [OpenGL ES 2.0.24] section 2.9 page 21.
#include "Buffer.h"
#include "main.h"
#include "VertexDataManager.h"
#include "IndexDataManager.h"
namespace es1
{
Buffer::Buffer(GLuint name) : NamedObject(name)
{
mContents = 0;
mSize = 0;
mUsage = GL_DYNAMIC_DRAW;
}
Buffer::~Buffer()
{
if(mContents)
{
mContents->destruct();
}
}
void Buffer::bufferData(const void *data, GLsizeiptr size, GLenum usage)
{
if(mContents)
{
mContents->destruct();
mContents = 0;
}
mSize = size;
mUsage = usage;
if(size > 0)
{
const int padding = 1024; // For SIMD processing of vertices
mContents = new sw::Resource(size + padding);
if(!mContents)
{
return error(GL_OUT_OF_MEMORY);
}
if(data)
{
memcpy((void*)mContents->data(), data, size);
}
}
}
void Buffer::bufferSubData(const void *data, GLsizeiptr size, GLintptr offset)
{
if(mContents)
{
char *buffer = (char*)mContents->lock(sw::PUBLIC);
memcpy(buffer + offset, data, size);
mContents->unlock();
}
}
sw::Resource *Buffer::getResource()
{
return mContents;
}
}
src/OpenGL/libGLES_CM/Buffer.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Buffer.h: Defines the Buffer class, representing storage of vertex and/or
// index data. Implements GL buffer objects and related functionality.
// [OpenGL ES 2.0.24] section 2.9 page 21.
#ifndef LIBGLES_CM_BUFFER_H_
#define LIBGLES_CM_BUFFER_H_
#include "common/Object.hpp"
#include "Common/Resource.hpp"
#include <GLES/gl.h>
#include <cstddef>
#include <vector>
namespace es1
{
class Buffer : public gl::NamedObject
{
public:
explicit Buffer(GLuint name);
virtual ~Buffer();
void bufferData(const void *data, GLsizeiptr size, GLenum usage);
void bufferSubData(const void *data, GLsizeiptr size, GLintptr offset);
const void *data() { return mContents ? mContents->data() : 0; }
size_t size() const { return mSize; }
GLenum usage() const { return mUsage; }
sw::Resource *getResource();
private:
sw::Resource *mContents;
size_t mSize;
GLenum mUsage;
};
}
#endif // LIBGLES_CM_BUFFER_H_
src/OpenGL/libGLES_CM/Device.hpp deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef gl_Device_hpp
#define gl_Device_hpp
#include "Renderer/Renderer.hpp"
namespace egl
{
class Image;
}
namespace es1
{
class Texture;
struct Viewport
{
int x0;
int y0;
unsigned int width;
unsigned int height;
float minZ;
float maxZ;
};
class Device : public sw::Renderer
{
public:
explicit Device(sw::Context *context);
virtual ~Device();
void *operator new(size_t size);
void operator delete(void * mem);
void clearColor(float red, float green, float blue, float alpha, unsigned int rgbaMask);
void clearDepth(float z);
void clearStencil(unsigned int stencil, unsigned int mask);
void drawIndexedPrimitive(sw::DrawType type, unsigned int indexOffset, unsigned int primitiveCount);
void drawPrimitive(sw::DrawType type, unsigned int primiveCount);
void setScissorEnable(bool enable);
void setRenderTarget(int index, egl::Image *renderTarget);
void setDepthBuffer(egl::Image *depthBuffer);
void setStencilBuffer(egl::Image *stencilBuffer);
void setScissorRect(const sw::Rect &rect);
void setViewport(const Viewport &viewport);
bool stretchRect(sw::Surface *sourceSurface, const sw::SliceRect *sourceRect, sw::Surface *destSurface, const sw::SliceRect *destRect, bool filter);
void finish();
private:
sw::Context *const context;
bool bindResources();
bool bindViewport(); // Also adjusts for scissoring
bool validRectangle(const sw::Rect *rect, sw::Surface *surface);
Viewport viewport;
sw::Rect scissorRect;
bool scissorEnable;
egl::Image *renderTarget;
egl::Image *depthBuffer;
egl::Image *stencilBuffer;
};
}
#endif // gl_Device_hpp
src/OpenGL/libGLES_CM/Framebuffer.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Framebuffer.h: Defines the Framebuffer class. Implements GL framebuffer
// objects and related functionality. [OpenGL ES 2.0.24] section 4.4 page 105.
#ifndef LIBGLES_CM_FRAMEBUFFER_H_
#define LIBGLES_CM_FRAMEBUFFER_H_
#include "common/Object.hpp"
#include "common/Image.hpp"
#include <GLES/gl.h>
namespace es1
{
class Renderbuffer;
class Colorbuffer;
class Depthbuffer;
class Stencilbuffer;
class DepthStencilbuffer;
class Framebuffer
{
public:
Framebuffer();
virtual ~Framebuffer();
void setColorbuffer(GLenum type, GLuint colorbuffer, GLint level = 0);
void setDepthbuffer(GLenum type, GLuint depthbuffer, GLint level = 0);
void setStencilbuffer(GLenum type, GLuint stencilbuffer, GLint level = 0);
void detachTexture(GLuint texture);
void detachRenderbuffer(GLuint renderbuffer);
egl::Image *getRenderTarget();
egl::Image *getDepthBuffer();
egl::Image *getStencilBuffer();
Renderbuffer *getColorbuffer();
Renderbuffer *getDepthbuffer();
Renderbuffer *getStencilbuffer();
GLenum getColorbufferType();
GLenum getDepthbufferType();
GLenum getStencilbufferType();
GLuint getColorbufferName();
GLuint getDepthbufferName();
GLuint getStencilbufferName();
bool hasStencil();
virtual GLenum completeness();
GLenum completeness(int &width, int &height, int &samples);
GLenum getImplementationColorReadFormat();
GLenum getImplementationColorReadType();
protected:
GLenum mColorbufferType;
gl::BindingPointer<Renderbuffer> mColorbufferPointer;
GLenum mDepthbufferType;
gl::BindingPointer<Renderbuffer> mDepthbufferPointer;
GLenum mStencilbufferType;
gl::BindingPointer<Renderbuffer> mStencilbufferPointer;
private:
Renderbuffer *lookupRenderbuffer(GLenum type, GLuint handle, GLint level) const;
};
class DefaultFramebuffer : public Framebuffer
{
public:
DefaultFramebuffer(Colorbuffer *colorbuffer, DepthStencilbuffer *depthStencil);
};
}
#endif // LIBGLES_CM_FRAMEBUFFER_H_
src/OpenGL/libGLES_CM/IndexDataManager.cpp deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// IndexDataManager.cpp: Defines the IndexDataManager, a class that
// runs the Buffer translation process for index buffers.
#include "IndexDataManager.h"
#include "Buffer.h"
#include "common/debug.h"
#include <string.h>
#include <algorithm>
namespace
{
enum { INITIAL_INDEX_BUFFER_SIZE = 4096 * sizeof(GLuint) };
}
namespace es1
{
IndexDataManager::IndexDataManager()
{
mStreamingBuffer = new StreamingIndexBuffer(INITIAL_INDEX_BUFFER_SIZE);
if(!mStreamingBuffer)
{
ERR("Failed to allocate the streaming index buffer.");
}
}
IndexDataManager::~IndexDataManager()
{
delete mStreamingBuffer;
}
void copyIndices(GLenum type, const void *input, GLsizei count, void *output)
{
if(type == GL_UNSIGNED_BYTE)
{
memcpy(output, input, count * sizeof(GLubyte));
}
else if(type == GL_UNSIGNED_SHORT)
{
memcpy(output, input, count * sizeof(GLushort));
}
else UNREACHABLE(type);
}
template<class IndexType>
void computeRange(const IndexType *indices, GLsizei count, GLuint *minIndex, GLuint *maxIndex)
{
*minIndex = indices[0];
*maxIndex = indices[0];
for(GLsizei i = 0; i < count; i++)
{
if(*minIndex > indices[i]) *minIndex = indices[i];
if(*maxIndex < indices[i]) *maxIndex = indices[i];
}
}
void computeRange(GLenum type, const void *indices, GLsizei count, GLuint *minIndex, GLuint *maxIndex)
{
if(type == GL_UNSIGNED_BYTE)
{
computeRange(static_cast<const GLubyte*>(indices), count, minIndex, maxIndex);
}
else if(type == GL_UNSIGNED_SHORT)
{
computeRange(static_cast<const GLushort*>(indices), count, minIndex, maxIndex);
}
else UNREACHABLE(type);
}
GLenum IndexDataManager::prepareIndexData(GLenum type, GLsizei count, Buffer *buffer, const void *indices, TranslatedIndexData *translated)
{
if(!mStreamingBuffer)
{
return GL_OUT_OF_MEMORY;
}
intptr_t offset = reinterpret_cast<intptr_t>(indices);
if(buffer != NULL)
{
if(typeSize(type) * count + offset > static_cast<std::size_t>(buffer->size()))
{
return GL_INVALID_OPERATION;
}
indices = static_cast<const GLubyte*>(buffer->data()) + offset;
}
StreamingIndexBuffer *streamingBuffer = mStreamingBuffer;
sw::Resource *staticBuffer = buffer ? buffer->getResource() : NULL;
if(staticBuffer)
{
computeRange(type, indices, count, &translated->minIndex, &translated->maxIndex);
translated->indexBuffer = staticBuffer;
translated->indexOffset = offset;
}
else
{
unsigned int streamOffset = 0;
int convertCount = count;
streamingBuffer->reserveSpace(convertCount * typeSize(type), type);
void *output = streamingBuffer->map(typeSize(type) * convertCount, &streamOffset);
if(output == NULL)
{
ERR("Failed to map index buffer.");
return GL_OUT_OF_MEMORY;
}
copyIndices(type, staticBuffer ? buffer->data() : indices, convertCount, output);
streamingBuffer->unmap();
computeRange(type, indices, count, &translated->minIndex, &translated->maxIndex);
translated->indexBuffer = streamingBuffer->getResource();
translated->indexOffset = streamOffset;
}
return GL_NO_ERROR;
}
std::size_t IndexDataManager::typeSize(GLenum type)
{
switch(type)
{
case GL_UNSIGNED_SHORT: return sizeof(GLushort);
case GL_UNSIGNED_BYTE: return sizeof(GLubyte);
default: UNREACHABLE(type); return sizeof(GLushort);
}
}
StreamingIndexBuffer::StreamingIndexBuffer(unsigned int initialSize) : mIndexBuffer(nullptr), mBufferSize(initialSize)
{
if(initialSize > 0)
{
mIndexBuffer = new sw::Resource(initialSize + 16);
if(!mIndexBuffer)
{
ERR("Out of memory allocating an index buffer of size %u.", initialSize);
}
}
mWritePosition = 0;
}
StreamingIndexBuffer::~StreamingIndexBuffer()
{
if(mIndexBuffer)
{
mIndexBuffer->destruct();
}
}
void *StreamingIndexBuffer::map(unsigned int requiredSpace, unsigned int *offset)
{
void *mapPtr = NULL;
if(mIndexBuffer)
{
mapPtr = (char*)mIndexBuffer->lock(sw::PUBLIC) + mWritePosition;
if(!mapPtr)
{
ERR(" Lock failed");
return NULL;
}
*offset = mWritePosition;
mWritePosition += requiredSpace;
}
return mapPtr;
}
void StreamingIndexBuffer::unmap()
{
if(mIndexBuffer)
{
mIndexBuffer->unlock();
}
}
void StreamingIndexBuffer::reserveSpace(unsigned int requiredSpace, GLenum type)
{
if(requiredSpace > mBufferSize)
{
if(mIndexBuffer)
{
mIndexBuffer->destruct();
mIndexBuffer = 0;
}
mBufferSize = std::max(requiredSpace, 2 * mBufferSize);
mIndexBuffer = new sw::Resource(mBufferSize + 16);
if(!mIndexBuffer)
{
ERR("Out of memory allocating an index buffer of size %u.", mBufferSize);
}
mWritePosition = 0;
}
else if(mWritePosition + requiredSpace > mBufferSize) // Recycle
{
if(mIndexBuffer)
{
mIndexBuffer->destruct();
mIndexBuffer = new sw::Resource(mBufferSize + 16);
}
mWritePosition = 0;
}
}
sw::Resource *StreamingIndexBuffer::getResource() const
{
return mIndexBuffer;
}
}
src/OpenGL/libGLES_CM/IndexDataManager.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// IndexDataManager.h: Defines the IndexDataManager, a class that
// runs the Buffer translation process for index buffers.
#ifndef LIBGLES_CM_INDEXDATAMANAGER_H_
#define LIBGLES_CM_INDEXDATAMANAGER_H_
#include "Context.h"
#include <GLES/gl.h>
namespace es1
{
struct TranslatedIndexData
{
unsigned int minIndex;
unsigned int maxIndex;
unsigned int indexOffset;
sw::Resource *indexBuffer;
};
class StreamingIndexBuffer
{
public:
StreamingIndexBuffer(unsigned int initialSize);
virtual ~StreamingIndexBuffer();
void *map(unsigned int requiredSpace, unsigned int *offset);
void unmap();
void reserveSpace(unsigned int requiredSpace, GLenum type);
sw::Resource *getResource() const;
private:
sw::Resource *mIndexBuffer;
unsigned int mBufferSize;
unsigned int mWritePosition;
};
class IndexDataManager
{
public:
IndexDataManager();
virtual ~IndexDataManager();
GLenum prepareIndexData(GLenum type, GLsizei count, Buffer *arrayElementBuffer, const void *indices, TranslatedIndexData *translated);
static std::size_t typeSize(GLenum type);
private:
StreamingIndexBuffer *mStreamingBuffer;
};
}
#endif // LIBGLES_CM_INDEXDATAMANAGER_H_
src/OpenGL/libGLES_CM/Renderbuffer.cpp deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Renderbuffer.cpp: the Renderbuffer class and its derived classes
// Colorbuffer, Depthbuffer and Stencilbuffer. Implements GL renderbuffer
// objects and related functionality. [OpenGL ES 2.0.24] section 4.4.3 page 108.
#include "Renderbuffer.h"
#include "main.h"
#include "Texture.h"
#include "utilities.h"
namespace es1
{
RenderbufferInterface::RenderbufferInterface()
{
}
// The default case for classes inherited from RenderbufferInterface is not to
// need to do anything upon the reference count to the parent Renderbuffer incrementing
// or decrementing.
void RenderbufferInterface::addProxyRef(const Renderbuffer *proxy)
{
}
void RenderbufferInterface::releaseProxy(const Renderbuffer *proxy)
{
}
GLuint RenderbufferInterface::getRedSize() const
{
return GetRedSize(getFormat());
}
GLuint RenderbufferInterface::getGreenSize() const
{
return GetGreenSize(getFormat());
}
GLuint RenderbufferInterface::getBlueSize() const
{
return GetBlueSize(getFormat());
}
GLuint RenderbufferInterface::getAlphaSize() const
{
return GetAlphaSize(getFormat());
}
GLuint RenderbufferInterface::getDepthSize() const
{
return GetDepthSize(getFormat());
}
GLuint RenderbufferInterface::getStencilSize() const
{
return GetStencilSize(getFormat());
}
///// RenderbufferTexture2D Implementation ////////
RenderbufferTexture2D::RenderbufferTexture2D(Texture2D *texture, GLint level) : mLevel(level)
{
mTexture2D = texture;
}
RenderbufferTexture2D::~RenderbufferTexture2D()
{
mTexture2D = nullptr;
}
// Textures need to maintain their own reference count for references via
// Renderbuffers acting as proxies. Here, we notify the texture of a reference.
void RenderbufferTexture2D::addProxyRef(const Renderbuffer *proxy)
{
mTexture2D->addProxyRef(proxy);
}
void RenderbufferTexture2D::releaseProxy(const Renderbuffer *proxy)
{
mTexture2D->releaseProxy(proxy);
}
// Increments refcount on image.
// caller must release() the returned image
egl::Image *RenderbufferTexture2D::getRenderTarget()
{
return mTexture2D->getRenderTarget(GL_TEXTURE_2D, 0);
}
// Increments refcount on image.
// caller must release() the returned image
egl::Image *RenderbufferTexture2D::createSharedImage()
{
return mTexture2D->createSharedImage(GL_TEXTURE_2D, 0);
}
bool RenderbufferTexture2D::isShared() const
{
return mTexture2D->isShared(GL_TEXTURE_2D, 0);
}
GLsizei RenderbufferTexture2D::getWidth() const
{
return mTexture2D->getWidth(GL_TEXTURE_2D, 0);
}
GLsizei RenderbufferTexture2D::getHeight() const
{
return mTexture2D->getHeight(GL_TEXTURE_2D, 0);
}
GLint RenderbufferTexture2D::getFormat() const
{
return mTexture2D->getFormat(GL_TEXTURE_2D, 0);
}
GLsizei RenderbufferTexture2D::getSamples() const
{
return 0;
}
////// Renderbuffer Implementation //////
Renderbuffer::Renderbuffer(GLuint name, RenderbufferInterface *instance) : NamedObject(name)
{
ASSERT(instance);
mInstance = instance;
}
Renderbuffer::~Renderbuffer()
{
delete mInstance;
}
// The RenderbufferInterface contained in this Renderbuffer may need to maintain
// its own reference count, so we pass it on here.
void Renderbuffer::addRef()
{
mInstance->addProxyRef(this);
Object::addRef();
}
void Renderbuffer::release()
{
mInstance->releaseProxy(this);
Object::release();
}
// Increments refcount on image.
// caller must Release() the returned image
egl::Image *Renderbuffer::getRenderTarget()
{
return mInstance->getRenderTarget();
}
// Increments refcount on image.
// caller must Release() the returned image
egl::Image *Renderbuffer::createSharedImage()
{
return mInstance->createSharedImage();
}
bool Renderbuffer::isShared() const
{
return mInstance->isShared();
}
GLsizei Renderbuffer::getWidth() const
{
return mInstance->getWidth();
}
GLsizei Renderbuffer::getHeight() const
{
return mInstance->getHeight();
}
GLint Renderbuffer::getLevel() const
{
return mInstance->getLevel();
}
GLenum Renderbuffer::getFormat() const
{
return mInstance->getFormat();
}
GLuint Renderbuffer::getRedSize() const
{
return mInstance->getRedSize();
}
GLuint Renderbuffer::getGreenSize() const
{
return mInstance->getGreenSize();
}
GLuint Renderbuffer::getBlueSize() const
{
return mInstance->getBlueSize();
}
GLuint Renderbuffer::getAlphaSize() const
{
return mInstance->getAlphaSize();
}
GLuint Renderbuffer::getDepthSize() const
{
return mInstance->getDepthSize();
}
GLuint Renderbuffer::getStencilSize() const
{
return mInstance->getStencilSize();
}
GLsizei Renderbuffer::getSamples() const
{
return mInstance->getSamples();
}
void Renderbuffer::setLevel(GLint level)
{
return mInstance->setLevel(level);
}
void Renderbuffer::setStorage(RenderbufferStorage *newStorage)
{
ASSERT(newStorage);
delete mInstance;
mInstance = newStorage;
}
RenderbufferStorage::RenderbufferStorage()
{
mWidth = 0;
mHeight = 0;
format = GL_NONE_OES;
mSamples = 0;
}
RenderbufferStorage::~RenderbufferStorage()
{
}
GLsizei RenderbufferStorage::getWidth() const
{
return mWidth;
}
GLsizei RenderbufferStorage::getHeight() const
{
return mHeight;
}
GLint RenderbufferStorage::getFormat() const
{
return format;
}
GLsizei RenderbufferStorage::getSamples() const
{
return mSamples;
}
Colorbuffer::Colorbuffer(egl::Image *renderTarget) : mRenderTarget(renderTarget)
{
if(renderTarget)
{
renderTarget->addRef();
mWidth = renderTarget->getWidth();
mHeight = renderTarget->getHeight();
format = renderTarget->getFormat();
mSamples = renderTarget->getDepth() & ~1;
}
}
Colorbuffer::Colorbuffer(int width, int height, GLenum internalformat, GLsizei samples) : mRenderTarget(nullptr)
{
int supportedSamples = Context::getSupportedMultisampleCount(samples);
if(width > 0 && height > 0)
{
if(height > sw::OUTLINE_RESOLUTION)
{
error(GL_OUT_OF_MEMORY);
return;
}
mRenderTarget = egl::Image::create(width, height, internalformat, supportedSamples, false);
if(!mRenderTarget)
{
error(GL_OUT_OF_MEMORY);
return;
}
}
mWidth = width;
mHeight = height;
format = internalformat;
mSamples = supportedSamples;
}
Colorbuffer::~Colorbuffer()
{
if(mRenderTarget)
{
mRenderTarget->release();
}
}
// Increments refcount on image.
// caller must release() the returned image
egl::Image *Colorbuffer::getRenderTarget()
{
if(mRenderTarget)
{
mRenderTarget->addRef();
}
return mRenderTarget;
}
// Increments refcount on image.
// caller must release() the returned image
egl::Image *Colorbuffer::createSharedImage()
{
if(mRenderTarget)
{
mRenderTarget->addRef();
mRenderTarget->markShared();
}
return mRenderTarget;
}
bool Colorbuffer::isShared() const
{
return mRenderTarget->isShared();
}
DepthStencilbuffer::DepthStencilbuffer(egl::Image *depthStencil) : mDepthStencil(depthStencil)
{
if(depthStencil)
{
depthStencil->addRef();
mWidth = depthStencil->getWidth();
mHeight = depthStencil->getHeight();
format = depthStencil->getFormat();
mSamples = depthStencil->getDepth() & ~1;
}
}
DepthStencilbuffer::DepthStencilbuffer(int width, int height, GLenum internalformat, GLsizei samples) : mDepthStencil(nullptr)
{
int supportedSamples = Context::getSupportedMultisampleCount(samples);
if(width > 0 && height > 0)
{
if(height > sw::OUTLINE_RESOLUTION)
{
error(GL_OUT_OF_MEMORY);
return;
}
mDepthStencil = egl::Image::create(width, height, internalformat, supportedSamples, false);
if(!mDepthStencil)
{
error(GL_OUT_OF_MEMORY);
return;
}
}
mWidth = width;
mHeight = height;
format = internalformat;
mSamples = supportedSamples;
}
DepthStencilbuffer::~DepthStencilbuffer()
{
if(mDepthStencil)
{
mDepthStencil->release();
}
}
// Increments refcount on image.
// caller must release() the returned image
egl::Image *DepthStencilbuffer::getRenderTarget()
{
if(mDepthStencil)
{
mDepthStencil->addRef();
}
return mDepthStencil;
}
// Increments refcount on image.
// caller must release() the returned image
egl::Image *DepthStencilbuffer::createSharedImage()
{
if(mDepthStencil)
{
mDepthStencil->addRef();
mDepthStencil->markShared();
}
return mDepthStencil;
}
bool DepthStencilbuffer::isShared() const
{
return mDepthStencil->isShared();
}
Depthbuffer::Depthbuffer(egl::Image *depthStencil) : DepthStencilbuffer(depthStencil)
{
}
Depthbuffer::Depthbuffer(int width, int height, GLenum internalformat, GLsizei samples) : DepthStencilbuffer(width, height, internalformat, samples)
{
}
Depthbuffer::~Depthbuffer()
{
}
Stencilbuffer::Stencilbuffer(egl::Image *depthStencil) : DepthStencilbuffer(depthStencil)
{
}
Stencilbuffer::Stencilbuffer(int width, int height, GLsizei samples) : DepthStencilbuffer(width, height, GL_STENCIL_INDEX8_OES, samples)
{
}
Stencilbuffer::~Stencilbuffer()
{
}
}
src/OpenGL/libGLES_CM/Renderbuffer.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Renderbuffer.h: Defines the wrapper class Renderbuffer, as well as the
// class hierarchy used to store its contents: RenderbufferStorage, Colorbuffer,
// DepthStencilbuffer, Depthbuffer and Stencilbuffer. Implements GL renderbuffer
// objects and related functionality. [OpenGL ES 2.0.24] section 4.4.3 page 108.
#ifndef LIBGLES_CM_RENDERBUFFER_H_
#define LIBGLES_CM_RENDERBUFFER_H_
#include "common/Object.hpp"
#include "common/Image.hpp"
#include <GLES/gl.h>
namespace es1
{
class Texture2D;
class Renderbuffer;
class Colorbuffer;
class DepthStencilbuffer;
class RenderbufferInterface
{
public:
RenderbufferInterface();
virtual ~RenderbufferInterface() {}
virtual void addProxyRef(const Renderbuffer *proxy);
virtual void releaseProxy(const Renderbuffer *proxy);
virtual egl::Image *getRenderTarget() = 0;
virtual egl::Image *createSharedImage() = 0;
virtual bool isShared() const = 0;
virtual GLsizei getWidth() const = 0;
virtual GLsizei getHeight() const = 0;
virtual GLint getLevel() const { return 0; }
virtual GLint getFormat() const = 0;
virtual GLsizei getSamples() const = 0;
virtual void setLevel(GLint) {}
GLuint getRedSize() const;
GLuint getGreenSize() const;
GLuint getBlueSize() const;
GLuint getAlphaSize() const;
GLuint getDepthSize() const;
GLuint getStencilSize() const;
};
class RenderbufferTexture2D : public RenderbufferInterface
{
public:
RenderbufferTexture2D(Texture2D *texture, GLint level);
~RenderbufferTexture2D() override;
void addProxyRef(const Renderbuffer *proxy) override;
void releaseProxy(const Renderbuffer *proxy) override;
egl::Image *getRenderTarget() override;
egl::Image *createSharedImage() override;
bool isShared() const override;
GLsizei getWidth() const override;
GLsizei getHeight() const override;
GLint getLevel() const override { return mLevel; }
GLint getFormat() const override;
GLsizei getSamples() const override;
void setLevel(GLint level) override { mLevel = level; }
private:
gl::BindingPointer<Texture2D> mTexture2D;
GLint mLevel;
};
// A class derived from RenderbufferStorage is created whenever glRenderbufferStorage
// is called. The specific concrete type depends on whether the internal format is
// colour depth, stencil or packed depth/stencil.
class RenderbufferStorage : public RenderbufferInterface
{
public:
RenderbufferStorage();
~RenderbufferStorage() override = 0;
egl::Image *getRenderTarget() override = 0;
egl::Image *createSharedImage() override = 0;
bool isShared() const override = 0;
GLsizei getWidth() const override;
GLsizei getHeight() const override;
GLint getFormat() const override;
GLsizei getSamples() const override;
protected:
GLsizei mWidth;
GLsizei mHeight;
GLenum format;
GLsizei mSamples;
};
// Renderbuffer implements the GL renderbuffer object.
// It's only a proxy for a RenderbufferInterface instance; the internal object
// can change whenever glRenderbufferStorage is called.
class Renderbuffer : public gl::NamedObject
{
public:
Renderbuffer(GLuint name, RenderbufferInterface *storage);
virtual ~Renderbuffer();
// These functions from Object are overloaded here because
// Textures need to maintain their own count of references to them via
// Renderbuffers/RenderbufferTextures. These functions invoke those
// reference counting functions on the RenderbufferInterface.
virtual void addRef();
virtual void release();
egl::Image *getRenderTarget();
virtual egl::Image *createSharedImage();
virtual bool isShared() const;
GLsizei getWidth() const;
GLsizei getHeight() const;
GLint getLevel() const;
GLenum getFormat() const;
GLuint getRedSize() const;
GLuint getGreenSize() const;
GLuint getBlueSize() const;
GLuint getAlphaSize() const;
GLuint getDepthSize() const;
GLuint getStencilSize() const;
GLsizei getSamples() const;
void setLevel(GLint level);
void setStorage(RenderbufferStorage *newStorage);
private:
RenderbufferInterface *mInstance;
};
class Colorbuffer : public RenderbufferStorage
{
public:
explicit Colorbuffer(egl::Image *renderTarget);
Colorbuffer(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples);
~Colorbuffer() override;
egl::Image *getRenderTarget() override;
egl::Image *createSharedImage() override;
bool isShared() const override;
private:
egl::Image *mRenderTarget;
};
class DepthStencilbuffer : public RenderbufferStorage
{
public:
explicit DepthStencilbuffer(egl::Image *depthStencil);
DepthStencilbuffer(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples);
~DepthStencilbuffer();
egl::Image *getRenderTarget() override;
egl::Image *createSharedImage() override;
bool isShared() const override;
protected:
egl::Image *mDepthStencil;
};
class Depthbuffer : public DepthStencilbuffer
{
public:
explicit Depthbuffer(egl::Image *depthStencil);
Depthbuffer(GLsizei width, GLsizei height, GLenum internalformat, GLsizei samples);
~Depthbuffer() override;
};
class Stencilbuffer : public DepthStencilbuffer
{
public:
explicit Stencilbuffer(egl::Image *depthStencil);
Stencilbuffer(GLsizei width, GLsizei height, GLsizei samples);
~Stencilbuffer() override;
};
}
#endif // LIBGLES_CM_RENDERBUFFER_H_
src/OpenGL/libGLES_CM/ResourceManager.cpp deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ResourceManager.cpp: Implements the ResourceManager class, which tracks and
// retrieves objects which may be shared by multiple Contexts.
#include "ResourceManager.h"
#include "Buffer.h"
#include "Renderbuffer.h"
#include "Texture.h"
namespace es1
{
ResourceManager::ResourceManager()
{
mRefCount = 1;
}
ResourceManager::~ResourceManager()
{
while(!mBufferNameSpace.empty())
{
deleteBuffer(mBufferNameSpace.firstName());
}
while(!mRenderbufferNameSpace.empty())
{
deleteRenderbuffer(mRenderbufferNameSpace.firstName());
}
while(!mTextureNameSpace.empty())
{
deleteTexture(mTextureNameSpace.firstName());
}
}
void ResourceManager::addRef()
{
mRefCount++;
}
void ResourceManager::release()
{
if(--mRefCount == 0)
{
delete this;
}
}
// Returns an unused buffer name
GLuint ResourceManager::createBuffer()
{
return mBufferNameSpace.allocate();
}
// Returns an unused texture name
GLuint ResourceManager::createTexture()
{
return mTextureNameSpace.allocate();
}
// Returns an unused renderbuffer name
GLuint ResourceManager::createRenderbuffer()
{
return mRenderbufferNameSpace.allocate();
}
void ResourceManager::deleteBuffer(GLuint buffer)
{
Buffer *bufferObject = mBufferNameSpace.remove(buffer);
if(bufferObject)
{
bufferObject->release();
}
}
void ResourceManager::deleteTexture(GLuint texture)
{
Texture *textureObject = mTextureNameSpace.remove(texture);
if(textureObject)
{
textureObject->release();
}
}
void ResourceManager::deleteRenderbuffer(GLuint renderbuffer)
{
Renderbuffer *renderbufferObject = mRenderbufferNameSpace.remove(renderbuffer);
if(renderbufferObject)
{
renderbufferObject->release();
}
}
Buffer *ResourceManager::getBuffer(unsigned int handle)
{
return mBufferNameSpace.find(handle);
}
Texture *ResourceManager::getTexture(unsigned int handle)
{
return mTextureNameSpace.find(handle);
}
Renderbuffer *ResourceManager::getRenderbuffer(unsigned int handle)
{
return mRenderbufferNameSpace.find(handle);
}
void ResourceManager::checkBufferAllocation(unsigned int buffer)
{
if(buffer != 0 && !getBuffer(buffer))
{
Buffer *bufferObject = new Buffer(buffer);
bufferObject->addRef();
mBufferNameSpace.insert(buffer, bufferObject);
}
}
void ResourceManager::checkTextureAllocation(GLuint texture, TextureType type)
{
if(!getTexture(texture) && texture != 0)
{
Texture *textureObject;
if(type == TEXTURE_2D)
{
textureObject = new Texture2D(texture);
}
else if(type == TEXTURE_EXTERNAL)
{
textureObject = new TextureExternal(texture);
}
else
{
UNREACHABLE(type);
return;
}
textureObject->addRef();
mTextureNameSpace.insert(texture, textureObject);
}
}
void ResourceManager::checkRenderbufferAllocation(GLuint handle)
{
if(handle != 0 && !getRenderbuffer(handle))
{
Renderbuffer *renderbufferObject = new Renderbuffer(handle, new Colorbuffer(0, 0, GL_RGBA4_OES, 0));
renderbufferObject->addRef();
mRenderbufferNameSpace.insert(handle, renderbufferObject);
}
}
}
src/OpenGL/libGLES_CM/ResourceManager.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ResourceManager.h : Defines the ResourceManager class, which tracks objects
// shared by multiple GL contexts.
#ifndef LIBGLES_CM_RESOURCEMANAGER_H_
#define LIBGLES_CM_RESOURCEMANAGER_H_
#include "common/NameSpace.hpp"
#include <GLES/gl.h>
#include <map>
namespace es1
{
class Buffer;
class Texture;
class Renderbuffer;
enum TextureType
{
TEXTURE_2D,
TEXTURE_EXTERNAL,
TEXTURE_TYPE_COUNT,
TEXTURE_UNKNOWN
};
class ResourceManager
{
public:
ResourceManager();
~ResourceManager();
void addRef();
void release();
GLuint createBuffer();
GLuint createTexture();
GLuint createRenderbuffer();
void deleteBuffer(GLuint buffer);
void deleteTexture(GLuint texture);
void deleteRenderbuffer(GLuint renderbuffer);
Buffer *getBuffer(GLuint handle);
Texture *getTexture(GLuint handle);
Renderbuffer *getRenderbuffer(GLuint handle);
void checkBufferAllocation(unsigned int buffer);
void checkTextureAllocation(GLuint texture, TextureType type);
void checkRenderbufferAllocation(GLuint handle);
private:
std::size_t mRefCount;
gl::NameSpace<Buffer> mBufferNameSpace;
gl::NameSpace<Texture> mTextureNameSpace;
gl::NameSpace<Renderbuffer> mRenderbufferNameSpace;
};
}
#endif // LIBGLES_CM_RESOURCEMANAGER_H_
src/OpenGL/libGLES_CM/Texture.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Texture.h: Defines the abstract Texture class and its concrete derived
// classes Texture2D and TextureCubeMap. Implements GL texture objects and
// related functionality. [OpenGL ES 2.0.24] section 3.7 page 63.
#ifndef LIBGLES_CM_TEXTURE_H_
#define LIBGLES_CM_TEXTURE_H_
#include "Renderbuffer.h"
#include "common/Object.hpp"
#include "utilities.h"
#include "libEGL/Texture.hpp"
#include "common/debug.h"
#include <GLES/gl.h>
#include <vector>
namespace gl { class Surface; }
namespace es1
{
class Framebuffer;
enum
{
IMPLEMENTATION_MAX_TEXTURE_LEVELS = sw::MIPMAP_LEVELS,
IMPLEMENTATION_MAX_TEXTURE_SIZE = 1 << (IMPLEMENTATION_MAX_TEXTURE_LEVELS - 1),
IMPLEMENTATION_MAX_CUBE_MAP_TEXTURE_SIZE = 1 << (IMPLEMENTATION_MAX_TEXTURE_LEVELS - 1),
IMPLEMENTATION_MAX_RENDERBUFFER_SIZE = sw::OUTLINE_RESOLUTION,
};
class Texture : public egl::Texture
{
public:
explicit Texture(GLuint name);
sw::Resource *getResource() const override;
virtual void addProxyRef(const Renderbuffer *proxy) = 0;
virtual void releaseProxy(const Renderbuffer *proxy) = 0;
virtual GLenum getTarget() const = 0;
bool setMinFilter(GLenum filter);
bool setMagFilter(GLenum filter);
bool setWrapS(GLenum wrap);
bool setWrapT(GLenum wrap);
bool setMaxAnisotropy(GLfloat textureMaxAnisotropy);
void setGenerateMipmap(GLboolean enable);
void setCropRect(GLint u, GLint v, GLint w, GLint h);
GLenum getMinFilter() const;
GLenum getMagFilter() const;
GLenum getWrapS() const;
GLenum getWrapT() const;
GLfloat getMaxAnisotropy() const;
GLboolean getGenerateMipmap() const;
GLint getCropRectU() const;
GLint getCropRectV() const;
GLint getCropRectW() const;
GLint getCropRectH() const;
virtual GLsizei getWidth(GLenum target, GLint level) const = 0;
virtual GLsizei getHeight(GLenum target, GLint level) const = 0;
virtual GLint getFormat(GLenum target, GLint level) const = 0;
virtual int getTopLevel() const = 0;
virtual bool isSamplerComplete() const = 0;
virtual bool isCompressed(GLenum target, GLint level) const = 0;
virtual bool isDepth(GLenum target, GLint level) const = 0;
virtual Renderbuffer *getRenderbuffer(GLenum target, GLint level) = 0;
virtual egl::Image *getRenderTarget(GLenum target, unsigned int level) = 0;
egl::Image *createSharedImage(GLenum target, unsigned int level);
virtual bool isShared(GLenum target, unsigned int level) const = 0;
virtual void generateMipmaps() = 0;
virtual void autoGenerateMipmaps() = 0;
virtual void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source) = 0;
protected:
~Texture() override;
void setImage(GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image);
void subImage(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels, egl::Image *image);
void setCompressedImage(GLsizei imageSize, const void *pixels, egl::Image *image);
void subImageCompressed(GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels, egl::Image *image);
bool copy(egl::Image *source, const sw::Rect &sourceRect, GLenum destFormat, GLint xoffset, GLint yoffset, egl::Image *dest);
bool isMipmapFiltered() const;
GLenum mMinFilter;
GLenum mMagFilter;
GLenum mWrapS;
GLenum mWrapT;
GLfloat mMaxAnisotropy;
GLboolean generateMipmap;
GLint cropRectU;
GLint cropRectV;
GLint cropRectW;
GLint cropRectH;
sw::Resource *resource;
};
class Texture2D : public Texture
{
public:
explicit Texture2D(GLuint name);
void addProxyRef(const Renderbuffer *proxy) override;
void releaseProxy(const Renderbuffer *proxy) override;
void sweep() override;
GLenum getTarget() const override;
GLsizei getWidth(GLenum target, GLint level) const override;
GLsizei getHeight(GLenum target, GLint level) const override;
GLint getFormat(GLenum target, GLint level) const override;
int getTopLevel() const override;
void setImage(GLint level, GLsizei width, GLsizei height, GLint internalformat, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels);
void setCompressedImage(GLint level, GLenum format, GLsizei width, GLsizei height, GLsizei imageSize, const void *pixels);
void subImage(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint unpackAlignment, const void *pixels);
void subImageCompressed(GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *pixels);
void copyImage(GLint level, GLenum format, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source);
void copySubImage(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height, Framebuffer *source) override;
void setSharedImage(egl::Image *image);
bool isSamplerComplete() const override;
bool isCompressed(GLenum target, GLint level) const override;
bool isDepth(GLenum target, GLint level) const override;
void bindTexImage(gl::Surface *surface);
void releaseTexImage() override;
void generateMipmaps() override;
void autoGenerateMipmaps() override;
Renderbuffer *getRenderbuffer(GLenum target, GLint level) override;
egl::Image *getRenderTarget(GLenum target, unsigned int level) override;
bool isShared(GLenum target, unsigned int level) const override;
egl::Image *getImage(unsigned int level);
protected:
~Texture2D() override;
bool isMipmapComplete() const;
egl::Image *image[IMPLEMENTATION_MAX_TEXTURE_LEVELS];
gl::Surface *mSurface;
// A specific internal reference count is kept for colorbuffer proxy references,
// because, as the renderbuffer acting as proxy will maintain a binding pointer
// back to this texture, there would be a circular reference if we used a binding
// pointer here. This reference count will cause the pointer to be set to null if
// the count drops to zero, but will not cause deletion of the Renderbuffer.
Renderbuffer *mColorbufferProxy;
unsigned int mProxyRefs;
};
class TextureExternal : public Texture2D
{
public:
explicit TextureExternal(GLuint name);
GLenum getTarget() const override;
protected:
~TextureExternal() override;
};
}
#endif // LIBGLES_CM_TEXTURE_H_
src/OpenGL/libGLES_CM/VertexDataManager.cpp deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// VertexDataManager.h: Defines the VertexDataManager, a class that
// runs the Buffer translation process.
#include "VertexDataManager.h"
#include "Buffer.h"
#include "IndexDataManager.h"
#include "common/debug.h"
#include <algorithm>
namespace
{
enum {INITIAL_STREAM_BUFFER_SIZE = 1024 * 1024};
}
namespace es1
{
VertexDataManager::VertexDataManager(Context *context) : mContext(context)
{
for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
mDirtyCurrentValue[i] = true;
mCurrentValueBuffer[i] = nullptr;
}
mStreamingBuffer = new StreamingVertexBuffer(INITIAL_STREAM_BUFFER_SIZE);
if(!mStreamingBuffer)
{
ERR("Failed to allocate the streaming vertex buffer.");
}
}
VertexDataManager::~VertexDataManager()
{
delete mStreamingBuffer;
for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
delete mCurrentValueBuffer[i];
}
}
unsigned int VertexDataManager::writeAttributeData(StreamingVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute)
{
Buffer *buffer = attribute.mBoundBuffer;
int inputStride = attribute.stride();
int elementSize = attribute.typeSize();
unsigned int streamOffset = 0;
char *output = nullptr;
if(vertexBuffer)
{
output = (char*)vertexBuffer->map(attribute, attribute.typeSize() * count, &streamOffset);
}
if(!output)
{
ERR("Failed to map vertex buffer.");
return ~0u;
}
const char *input = nullptr;
if(buffer)
{
int offset = attribute.mOffset;
input = static_cast<const char*>(buffer->data()) + offset;
}
else
{
input = static_cast<const char*>(attribute.mPointer);
}
input += inputStride * start;
if(inputStride == elementSize)
{
memcpy(output, input, count * inputStride);
}
else
{
for(int i = 0; i < count; i++)
{
memcpy(output, input, elementSize);
output += elementSize;
input += inputStride;
}
}
vertexBuffer->unmap();
return streamOffset;
}
GLenum VertexDataManager::prepareVertexData(GLint start, GLsizei count, TranslatedAttribute *translated)
{
if(!mStreamingBuffer)
{
return GL_OUT_OF_MEMORY;
}
const VertexAttributeArray &attribs = mContext->getVertexAttributes();
// Determine the required storage size per used buffer
for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
if(attribs[i].mArrayEnabled)
{
if(!attribs[i].mBoundBuffer)
{
mStreamingBuffer->addRequiredSpace(attribs[i].typeSize() * count);
}
}
}
mStreamingBuffer->reserveRequiredSpace();
// Perform the vertex data translations
for(int i = 0; i < MAX_VERTEX_ATTRIBS; i++)
{
if(attribs[i].mArrayEnabled)
{
Buffer *buffer = attribs[i].mBoundBuffer;
if(!buffer && attribs[i].mPointer == nullptr)
{
// This is an application error that would normally result in a crash, but we catch it and return an error
ERR("An enabled vertex array has no buffer and no pointer.");
return GL_INVALID_OPERATION;
}
sw::Resource *staticBuffer = buffer ? buffer->getResource() : nullptr;
if(staticBuffer)
{
translated[i].vertexBuffer = staticBuffer;
translated[i].offset = start * attribs[i].stride() + attribs[i].mOffset;
translated[i].stride = attribs[i].stride();
}
else
{
unsigned int streamOffset = writeAttributeData(mStreamingBuffer, start, count, attribs[i]);
if(streamOffset == ~0u)
{
return GL_OUT_OF_MEMORY;
}
translated[i].vertexBuffer = mStreamingBuffer->getResource();
translated[i].offset = streamOffset;
translated[i].stride = attribs[i].typeSize();
}
switch(attribs[i].mType)
{
case GL_BYTE: translated[i].type = sw::STREAMTYPE_SBYTE; break;
case GL_UNSIGNED_BYTE: translated[i].type = sw::STREAMTYPE_BYTE; break;
case GL_SHORT: translated[i].type = sw::STREAMTYPE_SHORT; break;
case GL_UNSIGNED_SHORT: translated[i].type = sw::STREAMTYPE_USHORT; break;
case GL_INT: translated[i].type = sw::STREAMTYPE_INT; break;
case GL_UNSIGNED_INT: translated[i].type = sw::STREAMTYPE_UINT; break;
case GL_FIXED: translated[i].type = sw::STREAMTYPE_FIXED; break;
case GL_FLOAT: translated[i].type = sw::STREAMTYPE_FLOAT; break;
default: UNREACHABLE(attribs[i].mType); translated[i].type = sw::STREAMTYPE_FLOAT; break;
}
translated[i].count = attribs[i].mSize;
translated[i].normalized = attribs[i].mNormalized;
}
else
{
if(mDirtyCurrentValue[i])
{
delete mCurrentValueBuffer[i];
mCurrentValueBuffer[i] = new ConstantVertexBuffer(attribs[i].mCurrentValue[0], attribs[i].mCurrentValue[1], attribs[i].mCurrentValue[2], attribs[i].mCurrentValue[3]);
mDirtyCurrentValue[i] = false;
}
translated[i].vertexBuffer = mCurrentValueBuffer[i]->getResource();
translated[i].type = sw::STREAMTYPE_FLOAT;
translated[i].count = 4;
translated[i].stride = 0;
translated[i].offset = 0;
}
}
return GL_NO_ERROR;
}
VertexBuffer::VertexBuffer(unsigned int size) : mVertexBuffer(nullptr)
{
if(size > 0)
{
mVertexBuffer = new sw::Resource(size + 1024);
if(!mVertexBuffer)
{
ERR("Out of memory allocating a vertex buffer of size %u.", size);
}
}
}
VertexBuffer::~VertexBuffer()
{
if(mVertexBuffer)
{
mVertexBuffer->destruct();
}
}
void VertexBuffer::unmap()
{
if(mVertexBuffer)
{
mVertexBuffer->unlock();
}
}
sw::Resource *VertexBuffer::getResource() const
{
return mVertexBuffer;
}
ConstantVertexBuffer::ConstantVertexBuffer(float x, float y, float z, float w) : VertexBuffer(4 * sizeof(float))
{
if(mVertexBuffer)
{
float *vector = (float*)mVertexBuffer->lock(sw::PUBLIC);
vector[0] = x;
vector[1] = y;
vector[2] = z;
vector[3] = w;
mVertexBuffer->unlock();
}
}
ConstantVertexBuffer::~ConstantVertexBuffer()
{
}
StreamingVertexBuffer::StreamingVertexBuffer(unsigned int size) : VertexBuffer(size)
{
mBufferSize = size;
mWritePosition = 0;
mRequiredSpace = 0;
}
StreamingVertexBuffer::~StreamingVertexBuffer()
{
}
void StreamingVertexBuffer::addRequiredSpace(unsigned int requiredSpace)
{
mRequiredSpace += requiredSpace;
}
void *StreamingVertexBuffer::map(const VertexAttribute &attribute, unsigned int requiredSpace, unsigned int *offset)
{
void *mapPtr = nullptr;
if(mVertexBuffer)
{
// We can use a private lock because we never overwrite the content
mapPtr = (char*)mVertexBuffer->lock(sw::PRIVATE) + mWritePosition;
*offset = mWritePosition;
mWritePosition += requiredSpace;
}
return mapPtr;
}
void StreamingVertexBuffer::reserveRequiredSpace()
{
if(mRequiredSpace > mBufferSize)
{
if(mVertexBuffer)
{
mVertexBuffer->destruct();
mVertexBuffer = 0;
}
mBufferSize = std::max(mRequiredSpace, 3 * mBufferSize / 2); // 1.5 x mBufferSize is arbitrary and should be checked to see we don't have too many reallocations.
mVertexBuffer = new sw::Resource(mBufferSize);
if(!mVertexBuffer)
{
ERR("Out of memory allocating a vertex buffer of size %u.", mBufferSize);
}
mWritePosition = 0;
}
else if(mWritePosition + mRequiredSpace > mBufferSize) // Recycle
{
if(mVertexBuffer)
{
mVertexBuffer->destruct();
mVertexBuffer = new sw::Resource(mBufferSize);
}
mWritePosition = 0;
}
mRequiredSpace = 0;
}
}
src/OpenGL/libGLES_CM/VertexDataManager.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// VertexDataManager.h: Defines the VertexDataManager, a class that
// runs the Buffer translation process.
#ifndef LIBGLES_CM_VERTEXDATAMANAGER_H_
#define LIBGLES_CM_VERTEXDATAMANAGER_H_
#include "Context.h"
#include "Device.hpp"
#include <GLES/gl.h>
namespace es1
{
struct TranslatedAttribute
{
sw::StreamType type;
int count;
bool normalized;
unsigned int offset;
unsigned int stride; // 0 means not to advance the read pointer at all
sw::Resource *vertexBuffer;
};
class VertexBuffer
{
public:
VertexBuffer(unsigned int size);
virtual ~VertexBuffer();
void unmap();
sw::Resource *getResource() const;
protected:
sw::Resource *mVertexBuffer;
};
class ConstantVertexBuffer : public VertexBuffer
{
public:
ConstantVertexBuffer(float x, float y, float z, float w);
~ConstantVertexBuffer();
};
class StreamingVertexBuffer : public VertexBuffer
{
public:
StreamingVertexBuffer(unsigned int size);
~StreamingVertexBuffer();
void *map(const VertexAttribute &attribute, unsigned int requiredSpace, unsigned int *streamOffset);
void reserveRequiredSpace();
void addRequiredSpace(unsigned int requiredSpace);
protected:
unsigned int mBufferSize;
unsigned int mWritePosition;
unsigned int mRequiredSpace;
};
class VertexDataManager
{
public:
VertexDataManager(Context *context);
virtual ~VertexDataManager();
void dirtyCurrentValue(int index) { mDirtyCurrentValue[index] = true; }
GLenum prepareVertexData(GLint start, GLsizei count, TranslatedAttribute *outAttribs);
private:
unsigned int writeAttributeData(StreamingVertexBuffer *vertexBuffer, GLint start, GLsizei count, const VertexAttribute &attribute);
Context *const mContext;
StreamingVertexBuffer *mStreamingBuffer;
bool mDirtyCurrentValue[MAX_VERTEX_ATTRIBS];
ConstantVertexBuffer *mCurrentValueBuffer[MAX_VERTEX_ATTRIBS];
};
}
#endif // LIBGLES_CM_VERTEXDATAMANAGER_H_
src/OpenGL/libGLES_CM/libGLES_CM.cpp deleted 100644 → 0
This source diff could not be displayed because it is too large. You can view the blob instead.
src/OpenGL/libGLES_CM/libGLES_CM.def deleted 100644 → 0
LIBRARY libGLES_CM
EXPORTS
eglBindTexImage @134
eglChooseConfig @1
eglCopyBuffers @2
eglCreateContext @3
eglCreatePbufferSurface @4
eglCreatePixmapSurface @5
eglCreateWindowSurface @6
eglDestroyContext @7
eglDestroySurface @8
eglGetConfigAttrib @9
eglGetConfigs @10
eglGetCurrentContext @11
eglGetCurrentDisplay @12
eglGetCurrentSurface @13
eglGetDisplay @14
eglGetError @15
eglGetProcAddress @16
eglInitialize @17
eglMakeCurrent @18
eglQueryContext @19
eglQueryString @20
eglQuerySurface @21
eglReleaseTexImage @135
eglSurfaceAttrib @133
eglSwapBuffers @22
eglSwapInterval @132
eglTerminate @23
eglWaitGL @24
eglWaitNative @25
glActiveTexture @26
glAlphaFunc @27
glAlphaFuncx @28
glBindBuffer @136
glBindTexture @29
glBlendFunc @30
glBufferData @137
glBufferSubData @138
glClear @31
glClearColor @32
glClearColorx @33
glClearDepthf @34
glClearDepthx @35
glClearStencil @36
glClientActiveTexture @37
glClipPlanef @139
glClipPlanex @140
glColor4f @38
glColor4ub @141
glColor4x @39
glColorMask @40
glColorPointer @41
glCompressedTexImage2D @42
glCompressedTexSubImage2D @43
glCopyTexImage2D @44
glCopyTexSubImage2D @45
glCullFace @46
glDeleteBuffers @142
glDeleteTextures @47
glDepthFunc @48
glDepthMask @49
glDepthRangef @50
glDepthRangex @51
glDisable @52
glDisableClientState @53
glDrawArrays @54
glDrawElements @55
glEnable @56
glEnableClientState @57
glFinish @58
glFlush @59
glFogf @60
glFogfv @61
glFogx @62
glFogxv @63
glFrontFace @64
glFrustumf @65
glFrustumx @66
glGenBuffers @147
glGenTextures @67
glGetBooleanv @143
glGetBufferParameteriv @144
glGetClipPlanef @145
glGetClipPlanex @146
glGetError @68
glGetFixedv @148
glGetFloatv @149
glGetIntegerv @69
glGetLightfv @150
glGetLightxv @151
glGetMaterialfv @152
glGetMaterialxv @153
glGetPointerv @154
glGetString @70
glGetTexEnvfv @156
glGetTexEnviv @155
glGetTexEnvxv @157
glGetTexParameterfv @159
glGetTexParameteriv @158
glGetTexParameterxv @160
glHint @71
glIsBuffer @161
glIsEnabled @162
glIsTexture @163
glLightModelf @72
glLightModelfv @73
glLightModelx @74
glLightModelxv @75
glLightf @76
glLightfv @77
glLightx @78
glLightxv @79
glLineWidth @80
glLineWidthx @81
glLoadIdentity @82
glLoadMatrixf @83
glLoadMatrixx @84
glLogicOp @85
glMaterialf @86
glMaterialfv @87
glMaterialx @88
glMaterialxv @89
glMatrixMode @90
glMultMatrixf @91
glMultMatrixx @92
glMultiTexCoord4f @93
glMultiTexCoord4x @94
glNormal3f @95
glNormal3x @96
glNormalPointer @97
glOrthof @98
glOrthox @99
glPixelStorei @100
glPointParameterf @164
glPointParameterfv @165
glPointParameterx @166
glPointParameterxv @167
glPointSize @101
glPointSizex @102
glPolygonOffset @103
glPolygonOffsetx @104
glPopMatrix @105
glPushMatrix @106
glReadPixels @107
glRotatef @108
glRotatex @109
glSampleCoverage @110
glSampleCoveragex @111
glScalef @112
glScalex @113
glScissor @114
glShadeModel @115
glStencilFunc @116
glStencilMask @117
glStencilOp @118
glTexCoordPointer @119
glTexEnvf @120
glTexEnvfv @121
glTexEnvi @169
glTexEnviv @174
glTexEnvx @122
glTexEnvxv @123
glTexImage2D @124
glTexParameterf @125
glTexParameterfv @171
glTexParameteri @170
glTexParameteriv @172
glTexParameterx @126
glTexParameterxv @173
glTexSubImage2D @127
glTranslatef @128
glTranslatex @129
glVertexPointer @130
glViewport @131
; Extensions
glPointSizePointerOES @168
glEGLImageTargetTexture2DOES
glEGLImageTargetRenderbufferStorageOES
glIsRenderbufferOES
glBindRenderbufferOES
glDeleteRenderbuffersOES
glGenRenderbuffersOES
glRenderbufferStorageOES
glGetRenderbufferParameterivOES
glIsFramebufferOES
glBindFramebufferOES
glDeleteFramebuffersOES
glGenFramebuffersOES
glCheckFramebufferStatusOES
glFramebufferRenderbufferOES
glFramebufferTexture2DOES
glGetFramebufferAttachmentParameterivOES
glGenerateMipmapOES
glBlendEquationOES
glBlendEquationSeparateOES
glBlendFuncSeparateOES
glDrawTexsOES
glDrawTexiOES
glDrawTexxOES
glDrawTexsvOES
glDrawTexivOES
glDrawTexxvOES
glDrawTexfOES
glDrawTexfvOES
eglCreateSyncKHR
eglDestroySyncKHR
eglClientWaitSyncKHR
eglGetSyncAttribKHR
libGLES_CM_swiftshader
src/OpenGL/libGLES_CM/libGLES_CM.exports deleted 100644 → 0
_eglBindAPI
_eglBindTexImage
_eglChooseConfig
_eglCopyBuffers
_eglCreateContext
_eglCreatePbufferSurface
_eglCreatePixmapSurface
_eglCreateWindowSurface
_eglDestroyContext
_eglDestroySurface
_eglGetConfigAttrib
_eglGetConfigs
_eglGetCurrentContext
_eglGetCurrentDisplay
_eglGetCurrentSurface
_eglGetDisplay
_eglGetError
_eglGetProcAddress
_eglInitialize
_eglMakeCurrent
_eglQueryContext
_eglQueryString
_eglQuerySurface
_eglReleaseTexImage
_eglSurfaceAttrib
_eglSwapBuffers
_eglSwapInterval
_eglTerminate
_eglWaitGL
_eglWaitNative
_glActiveTexture
_glAlphaFunc
_glAlphaFuncx
_glBindBuffer
_glBindTexture
_glBlendFunc
_glBufferData
_glBufferSubData
_glClear
_glClearColor
_glClearColorx
_glClearDepthf
_glClearDepthx
_glClearStencil
_glClientActiveTexture
_glClipPlanef
_glClipPlanex
_glColor4f
_glColor4ub
_glColor4x
_glColorMask
_glColorPointer
_glCompressedTexImage2D
_glCompressedTexSubImage2D
_glCopyTexImage2D
_glCopyTexSubImage2D
_glCullFace
_glDeleteBuffers
_glDeleteTextures
_glDepthFunc
_glDepthMask
_glDepthRangef
_glDepthRangex
_glDisable
_glDisableClientState
_glDrawArrays
_glDrawElements
_glEnable
_glEnableClientState
_glFinish
_glFlush
_glFogf
_glFogfv
_glFogx
_glFogxv
_glFrontFace
_glFrustumf
_glFrustumx
_glGenBuffers
_glGenTextures
_glGetBooleanv
_glGetBufferParameteriv
_glGetClipPlanef
_glGetClipPlanex
_glGetError
_glGetFixedv
_glGetFloatv
_glGetIntegerv
_glGetLightfv
_glGetLightxv
_glGetMaterialfv
_glGetMaterialxv
_glGetPointerv
_glGetString
_glGetTexEnvfv
_glGetTexEnviv
_glGetTexEnvxv
_glGetTexParameterfv
_glGetTexParameteriv
_glGetTexParameterxv
_glHint
_glIsBuffer
_glIsEnabled
_glIsTexture
_glLightModelf
_glLightModelfv
_glLightModelx
_glLightModelxv
_glLightf
_glLightfv
_glLightx
_glLightxv
_glLineWidth
_glLineWidthx
_glLoadIdentity
_glLoadMatrixf
_glLoadMatrixx
_glLogicOp
_glMaterialf
_glMaterialfv
_glMaterialx
_glMaterialxv
_glMatrixMode
_glMultMatrixf
_glMultMatrixx
_glMultiTexCoord4f
_glMultiTexCoord4x
_glNormal3f
_glNormal3x
_glNormalPointer
_glOrthof
_glOrthox
_glPixelStorei
_glPointParameterf
_glPointParameterfv
_glPointParameterx
_glPointParameterxv
_glPointSize
_glPointSizex
_glPolygonOffset
_glPolygonOffsetx
_glPopMatrix
_glPushMatrix
_glReadPixels
_glRotatef
_glRotatex
_glSampleCoverage
_glSampleCoveragex
_glScalef
_glScalex
_glScissor
_glShadeModel
_glStencilFunc
_glStencilMask
_glStencilOp
_glTexCoordPointer
_glTexEnvf
_glTexEnvfv
_glTexEnvi
_glTexEnviv
_glTexEnvx
_glTexEnvxv
_glTexImage2D
_glTexParameterf
_glTexParameterfv
_glTexParameteri
_glTexParameteriv
_glTexParameterx
_glTexParameterxv
_glTexSubImage2D
_glTranslatef
_glTranslatex
_glVertexPointer
_glViewport
# Extensions
_glPointSizePointerOES
_glEGLImageTargetTexture2DOES
_glEGLImageTargetRenderbufferStorageOES
_glIsRenderbufferOES
_glBindRenderbufferOES
_glDeleteRenderbuffersOES
_glGenRenderbuffersOES
_glRenderbufferStorageOES
_glGetRenderbufferParameterivOES
_glIsFramebufferOES
_glBindFramebufferOES
_glDeleteFramebuffersOES
_glGenFramebuffersOES
_glCheckFramebufferStatusOES
_glFramebufferRenderbufferOES
_glFramebufferTexture2DOES
_glGetFramebufferAttachmentParameterivOES
_glGenerateMipmapOES
_glBlendEquationOES
_glBlendEquationSeparateOES
_glBlendFuncSeparateOES
_glDrawTexsOES
_glDrawTexiOES
_glDrawTexxOES
_glDrawTexsvOES
_glDrawTexivOES
_glDrawTexxvOES
_glDrawTexfOES
_glDrawTexfvOES
_eglCreateSyncKHR
_eglDestroySyncKHR
_eglClientWaitSyncKHR
_eglGetSyncAttribKHR
_libGLES_CM_swiftshader
src/OpenGL/libGLES_CM/libGLES_CM.lds deleted 100644 → 0
{
global:
eglBindAPI;
eglBindTexImage;
eglChooseConfig;
eglCopyBuffers;
eglCreateContext;
eglCreatePbufferSurface;
eglCreatePixmapSurface;
eglCreateWindowSurface;
eglDestroyContext;
eglDestroySurface;
eglGetConfigAttrib;
eglGetConfigs;
eglGetCurrentContext;
eglGetCurrentDisplay;
eglGetCurrentSurface;
eglGetDisplay;
eglGetError;
eglGetProcAddress;
eglInitialize;
eglMakeCurrent;
eglQueryContext;
eglQueryString;
eglQuerySurface;
eglReleaseTexImage;
eglSurfaceAttrib;
eglSwapBuffers;
eglSwapInterval;
eglTerminate;
eglWaitGL;
eglWaitNative;
glActiveTexture;
glAlphaFunc;
glAlphaFuncx;
glBindBuffer;
glBindTexture;
glBlendFunc;
glBufferData;
glBufferSubData;
glClear;
glClearColor;
glClearColorx;
glClearDepthf;
glClearDepthx;
glClearStencil;
glClientActiveTexture;
glClipPlanef;
glClipPlanex;
glColor4f;
glColor4ub;
glColor4x;
glColorMask;
glColorPointer;
glCompressedTexImage2D;
glCompressedTexSubImage2D;
glCopyTexImage2D;
glCopyTexSubImage2D;
glCullFace;
glDeleteBuffers;
glDeleteTextures;
glDepthFunc;
glDepthMask;
glDepthRangef;
glDepthRangex;
glDisable;
glDisableClientState;
glDrawArrays;
glDrawElements;
glEnable;
glEnableClientState;
glFinish;
glFlush;
glFogf;
glFogfv;
glFogx;
glFogxv;
glFrontFace;
glFrustumf;
glFrustumx;
glGenBuffers;
glGenTextures;
glGetBooleanv;
glGetBufferParameteriv;
glGetClipPlanef;
glGetClipPlanex;
glGetError;
glGetFixedv;
glGetFloatv;
glGetIntegerv;
glGetLightfv;
glGetLightxv;
glGetMaterialfv;
glGetMaterialxv;
glGetPointerv;
glGetString;
glGetTexEnvfv;
glGetTexEnviv;
glGetTexEnvxv;
glGetTexParameterfv;
glGetTexParameteriv;
glGetTexParameterxv;
glHint;
glIsBuffer;
glIsEnabled;
glIsTexture;
glLightModelf;
glLightModelfv;
glLightModelx;
glLightModelxv;
glLightf;
glLightfv;
glLightx;
glLightxv;
glLineWidth;
glLineWidthx;
glLoadIdentity;
glLoadMatrixf;
glLoadMatrixx;
glLogicOp;
glMaterialf;
glMaterialfv;
glMaterialx;
glMaterialxv;
glMatrixMode;
glMultMatrixf;
glMultMatrixx;
glMultiTexCoord4f;
glMultiTexCoord4x;
glNormal3f;
glNormal3x;
glNormalPointer;
glOrthof;
glOrthox;
glPixelStorei;
glPointParameterf;
glPointParameterfv;
glPointParameterx;
glPointParameterxv;
glPointSize;
glPointSizex;
glPolygonOffset;
glPolygonOffsetx;
glPopMatrix;
glPushMatrix;
glReadPixels;
glRotatef;
glRotatex;
glSampleCoverage;
glSampleCoveragex;
glScalef;
glScalex;
glScissor;
glShadeModel;
glStencilFunc;
glStencilMask;
glStencilOp;
glTexCoordPointer;
glTexEnvf;
glTexEnvfv;
glTexEnvi;
glTexEnviv;
glTexEnvx;
glTexEnvxv;
glTexImage2D;
glTexParameterf;
glTexParameterfv;
glTexParameteri;
glTexParameteriv;
glTexParameterx;
glTexParameterxv;
glTexSubImage2D;
glTranslatef;
glTranslatex;
glVertexPointer;
glViewport;
# Extensions
glPointSizePointerOES;
glEGLImageTargetTexture2DOES;
glEGLImageTargetRenderbufferStorageOES;
glIsRenderbufferOES;
glBindRenderbufferOES;
glDeleteRenderbuffersOES;
glGenRenderbuffersOES;
glRenderbufferStorageOES;
glGetRenderbufferParameterivOES;
glIsFramebufferOES;
glBindFramebufferOES;
glDeleteFramebuffersOES;
glGenFramebuffersOES;
glCheckFramebufferStatusOES;
glFramebufferRenderbufferOES;
glFramebufferTexture2DOES;
glGetFramebufferAttachmentParameterivOES;
glGenerateMipmapOES;
glBlendEquationOES;
glBlendEquationSeparateOES;
glBlendFuncSeparateOES;
glDrawTexsOES;
glDrawTexiOES;
glDrawTexxOES;
glDrawTexsvOES;
glDrawTexivOES;
glDrawTexxvOES;
glDrawTexfOES;
glDrawTexfvOES;
eglCreateSyncKHR;
eglDestroySyncKHR;
eglClientWaitSyncKHR;
eglGetSyncAttribKHR;
libGLES_CM_swiftshader;
local:
*;
};
src/OpenGL/libGLES_CM/libGLES_CM.rc deleted 100644 → 0
// Microsoft Visual C++ generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include <windows.h>
#include "../../Common/Version.h"
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
// English (U.S.) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
#ifdef _WIN32
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
#pragma code_page(1252)
#endif //_WIN32
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE
BEGIN
"resource.h\0"
END
2 TEXTINCLUDE
BEGIN
"#include ""afxres.h""\r\n"
"#include ""../Common/Version.h""\0"
END
3 TEXTINCLUDE
BEGIN
"\r\n"
"\0"
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Version
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION MAJOR_VERSION,MINOR_VERSION,BUILD_VERSION,BUILD_REVISION
PRODUCTVERSION MAJOR_VERSION,MINOR_VERSION,BUILD_VERSION,BUILD_REVISION
FILEFLAGSMASK 0x17L
#ifdef _DEBUG
FILEFLAGS 0x1L
#else
FILEFLAGS 0x0L
#endif
FILEOS 0x4L
FILETYPE 0x2L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904b0"
BEGIN
#ifdef WIN64
VALUE "FileDescription", "SwiftShader libGLES_CM 64-bit Dynamic Link Library"
#else
VALUE "FileDescription", "SwiftShader libGLES_CM 32-bit Dynamic Link Library"
#endif
VALUE "FileVersion", VERSION_STRING
VALUE "InternalName", "libGLES_CM"
VALUE "LegalCopyright", "Copyright (C) 2016 Google Inc."
VALUE "OriginalFilename", "libGLES_CM.dll"
VALUE "PrivateBuild", VERSION_STRING
VALUE "ProductName", "SwiftShader libGLES_CM Dynamic Link Library"
VALUE "ProductVersion", VERSION_STRING
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1200
END
END
#endif // English (U.S.) resources
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED
src/OpenGL/libGLES_CM/main.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// main.h: Management of thread-local data.
#ifndef LIBGLES_CM_MAIN_H_
#define LIBGLES_CM_MAIN_H_
#include "Context.h"
#include "Device.hpp"
#include "common/debug.h"
#include "libEGL/libEGL.hpp"
#include "libEGL/Display.h"
#include <GLES/gl.h>
#include <GLES/glext.h>
namespace es1
{
Context *getContext();
Device *getDevice();
void error(GLenum errorCode);
template<class T>
const T &error(GLenum errorCode, const T &returnValue)
{
error(errorCode);
return returnValue;
}
}
extern LibEGL libEGL;
#endif // LIBGLES_CM_MAIN_H_
src/OpenGL/libGLES_CM/mathutil.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// mathutil.h: Math and bit manipulation functions.
#ifndef LIBGLES_CM_MATHUTIL_H_
#define LIBGLES_CM_MATHUTIL_H_
#include "common/debug.h"
#include "Common/Math.hpp"
namespace es1
{
inline bool isPow2(int x)
{
return (x & (x - 1)) == 0 && (x != 0);
}
inline int log2(int x)
{
int r = 0;
while((x >> r) > 1) r++;
return r;
}
inline unsigned int ceilPow2(unsigned int x)
{
if(x != 0) x--;
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
x++;
return x;
}
using sw::clamp;
using sw::clamp01;
template<const int n>
inline unsigned int unorm(float x)
{
const unsigned int max = 0xFFFFFFFF >> (32 - n);
if(x > 1)
{
return max;
}
else if(x < 0)
{
return 0;
}
else
{
return (unsigned int)(max * x + 0.5f);
}
}
}
#endif // LIBGLES_CM_MATHUTIL_H_
src/OpenGL/libGLES_CM/resource.h deleted 100644 → 0
//{{NO_DEPENDENCIES}}
// Microsoft Visual C++ generated include file.
// Used by libGLES_CM.rc
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 101
#define _APS_NEXT_COMMAND_VALUE 40001
#define _APS_NEXT_CONTROL_VALUE 1001
#define _APS_NEXT_SYMED_VALUE 101
#endif
#endif
src/OpenGL/libGLES_CM/utilities.h deleted 100644 → 0
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// utilities.h: Conversion functions and other utility routines.
#ifndef LIBGLES_CM_UTILITIES_H
#define LIBGLES_CM_UTILITIES_H
#include "Device.hpp"
#include "common/Image.hpp"
#include "Texture.h"
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <string>
namespace es1
{
struct Color;
bool IsCompressed(GLenum format);
GLenum ValidateSubImageParams(bool compressed, bool copy, GLenum target, GLint level, GLint xoffset, GLint yoffset,
GLsizei width, GLsizei height, GLenum format, GLenum type, Texture *texture);
bool IsDepthTexture(GLenum format);
bool IsStencilTexture(GLenum format);
bool IsCubemapTextureTarget(GLenum target);
int CubeFaceIndex(GLenum cubeTarget);
bool IsTextureTarget(GLenum target);
GLenum ValidateTextureFormatType(GLenum format, GLenum type, GLint internalformat, GLenum target);
bool IsColorRenderable(GLint internalformat);
bool IsDepthRenderable(GLint internalformat);
bool IsStencilRenderable(GLint internalformat);
GLuint GetAlphaSize(GLint internalformat);
GLuint GetRedSize(GLint internalformat);
GLuint GetGreenSize(GLint internalformat);
GLuint GetBlueSize(GLint internalformat);
GLuint GetDepthSize(GLint internalformat);
GLuint GetStencilSize(GLint internalformat);
bool IsAlpha(GLint texFormat);
bool IsRGB(GLint texFormat);
bool IsRGBA(GLint texFormat);
}
namespace es2sw
{
sw::DepthCompareMode ConvertDepthComparison(GLenum comparison);
sw::StencilCompareMode ConvertStencilComparison(GLenum comparison);
sw::AlphaCompareMode ConvertAlphaComparison(GLenum comparison);
sw::Color<float> ConvertColor(es1::Color color);
sw::BlendFactor ConvertBlendFunc(GLenum blend);
sw::BlendOperation ConvertBlendOp(GLenum blendOp);
sw::LogicalOperation ConvertLogicalOperation(GLenum logicalOperation);
sw::StencilOperation ConvertStencilOp(GLenum stencilOp);
sw::AddressingMode ConvertTextureWrap(GLenum wrap);
sw::CullMode ConvertCullMode(GLenum cullFace, GLenum frontFace);
unsigned int ConvertColorMask(bool red, bool green, bool blue, bool alpha);
sw::MipmapType ConvertMipMapFilter(GLenum minFilter);
sw::FilterType ConvertTextureFilter(GLenum minFilter, GLenum magFilter, float maxAnisotropy);
bool ConvertPrimitiveType(GLenum primitiveType, GLsizei elementCount, GLenum elementType, sw::DrawType &swPrimitiveType, int &primitiveCount);
sw::TextureStage::StageOperation ConvertCombineOperation(GLenum operation);
sw::TextureStage::SourceArgument ConvertSourceArgument(GLenum argument);
sw::TextureStage::ArgumentModifier ConvertSourceOperand(GLenum operand);
}
namespace sw2es
{
GLenum ConvertBackBufferFormat(sw::Format format);
GLenum ConvertDepthStencilFormat(sw::Format format);
}
#endif // LIBGLES_CM_UTILITIES_H
src/OpenGL/libGLESv2/entry_points.cpp
...@@ -14,9 +14,9 @@ ...@@ -14,9 +14,9 @@
// entry_points.cpp: GL entry points exports and definition // entry_points.cpp: GL entry points exports and definition
#include "main.h"
#include "entry_points.h" #include "entry_points.h"
#include "libEGL/main.h" #include "libEGL/main.h"
#include "main.h"
extern "C" extern "C"
{ {
...@@ -1752,4 +1752,3 @@ extern "C" GL_APICALL LibGLESv2exports *libGLESv2_swiftshader() ...@@ -1752,4 +1752,3 @@ extern "C" GL_APICALL LibGLESv2exports *libGLESv2_swiftshader()
} }
LibEGL libEGL; LibEGL libEGL;
LibGLES_CM libGLES_CM;
src/OpenGL/libGLESv2/libGLESv2.cpp
...@@ -13,22 +13,22 @@ ...@@ -13,22 +13,22 @@
// limitations under the License. // limitations under the License.
// libGLESv2.cpp: Implements the exported OpenGL ES 2.0 functions. // libGLESv2.cpp: Implements the exported OpenGL ES 2.0 functions.
#include "main.h"
#include "mathutil.h"
#include "utilities.h"
#include "Buffer.h" #include "Buffer.h"
#include "Common/Version.h"
#include "Context.h" #include "Context.h"
#include "Fence.h" #include "Fence.h"
#include "Framebuffer.h" #include "Framebuffer.h"
#include "Program.h" #include "Program.h"
#include "Query.h"
#include "Renderbuffer.h" #include "Renderbuffer.h"
#include "Shader.h" #include "Shader.h"
#include "Texture.h" #include "Texture.h"
#include "Query.h"
#include "TransformFeedback.h" #include "TransformFeedback.h"
#include "VertexArray.h" #include "VertexArray.h"
#include "common/debug.h" #include "common/debug.h"
#include "Common/Version.h" #include "main.h"
#include "mathutil.h"
#include "utilities.h"
#include <GLES2/gl2.h> #include <GLES2/gl2.h>
#include <GLES2/gl2ext.h> #include <GLES2/gl2ext.h>
...@@ -6065,11 +6065,6 @@ void GL_APIENTRY FramebufferTexture3DOES(GLenum target, GLenum attachment, GLenu ...@@ -6065,11 +6065,6 @@ void GL_APIENTRY FramebufferTexture3DOES(GLenum target, GLenum attachment, GLenu
void GL_APIENTRY EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) void GL_APIENTRY EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
{ {
if(egl::getClientVersion() == 1)
{
return libGLES_CM->glEGLImageTargetTexture2DOES(target, image);
}
TRACE("(GLenum target = 0x%X, GLeglImageOES image = %p)", target, image); TRACE("(GLenum target = 0x%X, GLeglImageOES image = %p)", target, image);
switch(target) switch(target)
......
src/OpenGL/libGLESv2/libGLESv2.hpp
...@@ -15,16 +15,16 @@ ...@@ -15,16 +15,16 @@
#ifndef libGLESv2_hpp #ifndef libGLESv2_hpp
#define libGLESv2_hpp #define libGLESv2_hpp
#include <EGL/egl.h>
#include <GLES/gl.h> #include <GLES/gl.h>
#include <GLES/glext.h> #include <GLES/glext.h>
#include <EGL/egl.h>
#include "Common/SharedLibrary.hpp" #include "Common/SharedLibrary.hpp"
#include "Renderer/Surface.hpp"
namespace sw namespace sw
{ {
class FrameBuffer; class FrameBuffer;
enum Format ENUM_UNDERLYING_TYPE_UNSIGNED_INT;
} }
namespace egl namespace egl
......
src/OpenGL/libGLESv2/main.h
...@@ -20,9 +20,8 @@ ...@@ -20,9 +20,8 @@
#include "Context.h" #include "Context.h"
#include "Device.hpp" #include "Device.hpp"
#include "common/debug.h" #include "common/debug.h"
#include "libEGL/libEGL.hpp"
#include "libEGL/Display.h" #include "libEGL/Display.h"
#include "libGLES_CM/libGLES_CM.hpp" #include "libEGL/libEGL.hpp"
#include <GLES2/gl2.h> #include <GLES2/gl2.h>
#include <GLES2/gl2ext.h> #include <GLES2/gl2ext.h>
...@@ -51,6 +50,5 @@ namespace egl ...@@ -51,6 +50,5 @@ namespace egl
} }
extern LibEGL libEGL; extern LibEGL libEGL;
extern LibGLES_CM libGLES_CM;
#endif // LIBGLESV2_MAIN_H_ #endif // LIBGLESV2_MAIN_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment