glShaderSource strings are concatenated into a single string
before sent over the wire protocol. The wire protocol transfer is
done using a special api call 'glShaderString'
Change-Id: I90c157df66fe82fee17c460a1e7852d370c77088
Shader strings are sent over the wire protocal as one concatenated
string. a special api call - glShaderString is used to handle the
encoding and decoding of this string.
Change-Id: Id682763f35e9fcc6215559931db2112a4fa981a9
Use seperate EGL_emul, GLESv1_CM_emul and GLESv2_emul implementation
libraries. This replaces GLES_emul that was prviously included
EGL and GLESv1.
This change enables the wrapper to support GLESv2. However,
this current EGL implementation uses the native android emulator
EGL thus will not expose this GLESv2 capability.
Change-Id: Ib0a309d71cce1248efe9a08aa59434101d0ac607
Add functionality to generate a wrapper library. A wrapper library includes:
1. entry points
2. dispatch table (accessed from the library entry points)
3. dispatch table accessor callback
4. dispatch table initialization function
Note that the dispatch table initialization function used to be part of the decoder. This
change moves it to be part of the dispatch table layer where it belongs.
Change-Id: Ide6764a17cc029056f9946e778a513cdc2a49003
Match the location type in the decoder context data to take
int locations rather then symbolic constants.
Change-Id: I353e43315c90dbeafe4820a3749a0d1cf0848d4b
make the number of suppoted vertex attributes (by the codec)
common across the encoder and the decoder.
Change-Id: I699ef62821566cec0764982872adb92ebb8861e9
Extends GLClientState to support additional state data
that is required by GLESv2. this includes:
* normalized flag in vertex attribute arrays
* getter for vertex attribute arrays state
* glParamSize now knows about the result size of GL2 parameters
* utility functions required for a GLESv2 encoder
Change-Id: I7e57d978bed5b8b929b918aee66c7f71dc5df3b1
This fixes several issues when building the host libraris on Darwin.
Note that there is still not proper implementation of backend functions.
Change-Id: I3ba4120df6545a8c2aa62fdfcaadaf5ff4972456
This is the EGL implementation for the host EGL/GLES translator.
EglImp.cpp - includes the EGL entry points implementation.
ThreadInfo.cpp - defines the per-thread info which is shared to EGL and GLES
EglOsApi.h - platform dependant interface functions.
EglLinuxApi.cpp - implements the GLX platform of EglOsApi
EglWindowsApi.cpp - implenents the Windows platform of EglOsApi - This has not been compiled yet!!!
Change-Id: I30a8cf457858ef04febf67005787d8d18e5e7a70
This is the GLESv1 on top of OpenGL implementation on the host.
GLDispatch - dispatch table to host OpenGL implementation.
GLESimp - includes GLES entry points implementation.
Change-Id: Ief5eac2253a5a98b75a5d76363a36b7587d17391
This fix adds support for OpenGLES 1.1 extensions in the codec
layer. This fix also includes bug fixes in GLEncoder (client-state)
and gles android wrapper modules.
Change-Id: I512649724d43e4af9d3ce5d49ae66d9f4da0b823
This sample program simulates the use of the renderer api as it should
be used from the emulator program. It opens a SDL window, initialize the
renderer, process events on the window and terminate the renderer when the
window is closed.
Change-Id: If983b4ce6465dee71f548e8edaf2b56b6443f7b0
This is the host renderer executable. It is a small process which
just calls into libOpenglRender library. The process is invoked
through the initOpenGLRenderer function of libOpenglRenderer.
Change-Id: I85af075b5eb751ffb9543ecbd8e7fc155054f146
This is a library which includes all the OpenGL renderer functionality,
it is packaged in a library so that both the renderer process and the emulator
program will be able to use that functionality.
NOTES:
1) gl_proc.h and GLDispatch.{h,cpp} in this commit will be replaced
with the decoder auto-generated dispatch in a later commit, the
auto-generated dispatch is currently missing some extension functions
required for the renderer.
2) look at host/include/libOpenglRender/render_api.h for the external
interface defined for this library (to be used by the emulator).
The following is a description of each component:
FrameBuffer - The main object which manages the framebuffer and color buffers.
This is a singleton which get initialized through its initialize
static function. It initializes the OpenGL renderer and must be
called first. This initialization function is not thread safe so
it must be called before any thread that is calling to this
library is created.
FBConfig - Includes a static set of configs supported by the renderer which get
initialized during FrameBuffer initialization phase. Also,
an instance of this class includes the a description of one frame
buffer configuration supported by the renderer.
RenderContext - encapsulate a rendering context state.
ColorBuffer - implements a color buffer object as a texture which can be bind
as render target or source.
WindowSurface - implements the functionality of a native window which can be
bound to a rendering context and its target ColorBuffer can
be specified and replaced.
ThreadInfo - holds per-thread information.
EGLDispatch - loads the EGL plugin library, all egl calls are made through
this dispatch table which get initialized during initialization
phase.
GLDispatch - loads the GLES plugin library, all GLES calls are made through
this dispatch table which get initialized during initialization
phase - This will be replaced by the auto-generated code of the
decoder ...
RenderThread - implements a thread that reads command tokens from an IOStream
and decode it.
RenderControl - implements the host side implementation of the renderControl
API, when a renderControl token is decoded from the stream
it is dispatched to this implementation.
RenderServer - implements a TCP server which listens to port number and
launcges a RenderThread for each new connection.
Change-Id: I9f34d17bdfcb715893a13cd30086c767f499df87
This is just a set of OS dependant functionality needed by the
emulator OpenGL host renderer. It currently has implementation for
Linux and Windows only.
osDynLibrary - dlopen/dlsym abstraction
osProcess - interface to launch a new process, wait and kill it.
osThread - abstraction interface for creating a thread.
Change-Id: Ib0264592d8c87e865da87acf5c94e2b331801ca4
This is the emulator opengl implementation of gralloc.
NOTE that it is currently build only if BUILD_EMULATOR_OPENGL_DRIVER
is defined, This is because the other driver peices (EGL/GLES) are
still missing.
Change-Id: If48f5ed619df6efb00cb4e590d99ce49d87875f6
This is a static library of utilities shared between the emulator opengl
system components, gralloc, EGL, GLES. In includes host connection functionality
and access to OpenGL TLS info.
Change-Id: Ic63a6f7384a2035308ca6d316c747f0e6c6f2ef3
That adds the renderControl API encoder/decoder which is used for
guest to host control commands. See system/renderControl_enc/README
for more info about the API itself.
Change-Id: I2c72803137889d646fbb3d2a56ecdcf94b088f40
moved pixel size calculation from GLClientState to glUtils to be used
outside the client state scope. (needed for the renderControl encoder
which will follow in next commit).
Change-Id: I5adbc40b241537054c6743e2afc52ba44454664f
This change includes four changes:
1) moved IOStream.h into host/include/libOpenGLRender, this directory
will include the api interface into the libOpenGLRender which will be
used later by the emulator and we need this interface to use IOStream.h
2) Updated Andorid.mk files to include the new directory location of IOStream.h
in the LOCAL_C_INCLUDE.
3) Added new function "read" to IOStream which reads a message without a givven
size.
4) Updated TcpStream to use "cutils/sockets.h" instead of using directly the socket api for portability reasons. (It now compiles on windows as well).
Change-Id: I30eb40c8dcd5aacf0d993aff9cdb90b283b12dde
It includes code that is shared with all three components:
ThreadInfo.h - defines a structure of information stored in the TLS.
TranslatorIfaces - defines the interface between EGL and its client APIs (GLES and GLESv2)
objectrNameManager - manages the set of OpenGL objects in share groups name space.
Change-Id: Idb1bd1e2c3dcbb5dac7ba4ea85f78da856b897d9
Moved 'isPointer' attribute from variable to type field.
The .types input file now includes new column specifying if a type is a pointer or not
previously emugen declared as pointer only types which included '*' character but did not
process well the case of 'char **' (pointer to pointer).
Fixed the gl.types and ut_rendercontrol.types accordingly.
Few other fixes to gl.attrib and gl.in.
Change-Id: Ifd3591119dfa504703c68556802a40e38fe4940e
Move system/OpenglCodecCommon into shared/OpenglCodecCommon so it's code
can be shared among more components of the project.
Move tests/ut_renderer/TimeUtils.* into a the common area
Annotate ErrLog.h and GLDecoderContextData.h with the project license statement
Change-Id: Ieea42e95edd5ad89fda4cfa40356a012304ee976
This patch ensures that the egl.cfg file specific to our
hardware OpenGL emulation is only copied to the system images
of emulator-specific build products.
This fixes a conflict for device-specific products (which provide
their own hw-specific egl.cfg).
Change-Id: I30cd64ba5915e5ffdc1091de8db20f6c3c671486
This is a temporary patch until we update the prebuilt/ tree accordingly
to include libxcb.so for Linux.
Change-Id: I76d9966bfb73bf3f5ca35cc30f6e12fb262dc2b2
This adds an EGL wrapper used by the test rendering to load an EGL
implementation that matches the OpenGL ES impelmentation that it uses.
The library is a simple wrapper that direct EGL calls through a dispatch
table that is dynamically loaded from an EGL shared library implementation
Change-Id: I6379d6b156c69f9e017da0039c96699290f0f84f
This adds 'ut_renderer' - a host side unit test renderer. ut_renderer is used to
take a command stream over a socket connection and render it into an opengl window.
The renderer uses the GLESv1_dec decoder library and the ut_rendercontrol api to parse
the command stream.
The ut_renderer uses an external (plug-in) opengl impelementation.
Change-Id: I77794044ca9ca8a75a66a95a248eac384710aafe
This adds opengl es implementation driver that selects whether to use
the native android emulator opengl impelementation or use a remote,
host side renderer. This driver is used to selectivley run applications using
the remote renderer. The selection is based on the application/process name and
is configured using /etc/gles_emul.cfg in the emulator side.
This change also installs /etc/egl.cfg that is used by the Android opengl wrapper
to select an opengl implementation
Change-Id: I66eda3d48938f8057bf45e6476b7faefaf1130fb
