diff options
Diffstat (limited to 'Runtime/GfxDevice/opengles30/GfxDeviceGLES30.cpp')
| -rw-r--r-- | Runtime/GfxDevice/opengles30/GfxDeviceGLES30.cpp | 3328 |
1 files changed, 3328 insertions, 0 deletions
diff --git a/Runtime/GfxDevice/opengles30/GfxDeviceGLES30.cpp b/Runtime/GfxDevice/opengles30/GfxDeviceGLES30.cpp new file mode 100644 index 0000000..240cb58 --- /dev/null +++ b/Runtime/GfxDevice/opengles30/GfxDeviceGLES30.cpp @@ -0,0 +1,3328 @@ +#include "UnityPrefix.h" +#if GFX_SUPPORTS_OPENGLES30 +#include "Runtime/Graphics/ScreenManager.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "Runtime/Shaders/GraphicsCaps.h" +#include "Runtime/Shaders/MaterialProperties.h" +#include "External/shaderlab/Library/texenv.h" +#include "External/shaderlab/Library/TextureBinding.h" +#include "Runtime/Misc/Allocator.h" +#include "Runtime/Math/Matrix4x4.h" +#include "Runtime/Math/Quaternion.h" +#include "External/shaderlab/Library/shaderlab.h" +#include "External/shaderlab/Library/properties.h" +#include "External/shaderlab/Library/program.h" +#include "Runtime/Graphics/RenderTexture.h" +#include "Runtime/Graphics/Image.h" +#include "Runtime/Threads/AtomicOps.h" +#include "Runtime/GfxDevice/TransformState.h" +#include "IncludesGLES30.h" +#include "AssertGLES30.h" +#include "ConstantBuffersGLES30.h" +#include "ContextGLES30.h" +#include "VBOGLES30.h" +#include "TexturesGLES30.h" +#include "CombinerGLES30.h" +#include "GpuProgramsGLES30.h" +#include "FixedFunctionStateGLES30.h" +#include "ShaderGeneratorGLES30.h" +#include "RenderTextureGLES30.h" +#include "DebugGLES30.h" +#include "TimerQueryGLES30.h" +#include "TextureIdMapGLES30.h" +#include "UtilsGLES30.h" +#include "Runtime/GfxDevice/opengles30/TransformFeedbackSkinnedMesh.h" +#include "DataBuffersGLES30.h" +#include "Runtime/GfxDevice/opengles/ExtensionsGLES.h" + +#if UNITY_IPHONE + #include "PlatformDependent/iPhonePlayer/iPhoneSettings.h" +#elif UNITY_ANDROID + #include "PlatformDependent/AndroidPlayer/ContextGLES.h" + #include "PlatformDependent/AndroidPlayer/EntryPoint.h" + #include "PlatformDependent/AndroidPlayer/AndroidSystemInfo.h" +#endif + +#include "Runtime/GfxDevice/GLDataBufferCommon.h" + +#define UNITY_GLES3_ENTRYPOINTS_FROM_GETPROCADDR 0 + +#if UNITY_ANDROID +#undef UNITY_GLES3_ENTRYPOINTS_FROM_GETPROCADDR +#define UNITY_GLES3_ENTRYPOINTS_FROM_GETPROCADDR 1 +#endif + +#if UNITY_GLES3_ENTRYPOINTS_FROM_GETPROCADDR + +#define STRINGIFY(x) STRINGIFY2(x) +#define STRINGIFY2(x) #x + +#define DO_GLFUNC(retval, name, ...) typedef void (GL_APIENTRYP PFN##name) (__VA_ARGS__); \ + retval GL_APIENTRY name (__VA_ARGS__) \ +{ \ + static PFN##name addr = NULL; \ + if(!addr) \ + { \ + /*DBG_LOG_GLES30("Retrieving GLES3 proc address " STRINGIFY(name) );*/ \ + addr = (PFN##name) GetGLExtProcAddress(STRINGIFY(name)); \ + if(!addr) \ + { \ + Assert("Could not find GLES 3.0 entry point" STRINGIFY(name)); \ + return (retval)0; \ + } \ + DBG_LOG_GLES30("Success\n"); \ + } \ + __builtin_return(__builtin_apply((void (*)(...))addr, __builtin_apply_args(), 100)); \ + /*DBG_LOG_GLES30("Called " STRINGIFY(name) " successfully\n");*/ \ +} + +DO_GLFUNC(void, glBindBufferBase, GLenum target, GLuint index, GLuint buffer) +DO_GLFUNC(void, glBindBufferRange, GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr range) +DO_GLFUNC(void, glBlitFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) +DO_GLFUNC(void, glDeleteTransformFeedbacks, GLsizei n, const GLuint* ids) +DO_GLFUNC(void, glDrawBuffers, GLsizei n, const GLenum* bufs) +DO_GLFUNC(void, glGenQueries, GLsizei n, GLuint* ids) +DO_GLFUNC(void, glGetActiveUniformBlockiv, GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) +DO_GLFUNC(void, glGetActiveUniformBlockName, GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) +DO_GLFUNC(void, glGetActiveUniformsiv, GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) +DO_GLFUNC(void, glGetProgramBinary, GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) +DO_GLFUNC(void, glGetQueryObjectuiv, GLuint id, GLenum pname, GLuint* params) +DO_GLFUNC(GLuint, glGetUniformBlockIndex, GLuint program, const GLchar *uniformBlockName) +DO_GLFUNC(void, glInvalidateFramebuffer, GLenum target, GLsizei numAttachments, const GLenum* attachments) +DO_GLFUNC(void *, glMapBufferRange, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) +DO_GLFUNC(void, glProgramBinary, GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) +DO_GLFUNC(void, glReadBuffer, GLenum buf) +DO_GLFUNC(void, glRenderbufferStorageMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) +DO_GLFUNC(void, glUniformBlockBinding, GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) +DO_GLFUNC(GLboolean, glUnmapBuffer, GLenum target) +DO_GLFUNC(void, glGenTransformFeedbacks, GLsizei n, GLuint *ids) +DO_GLFUNC(void, glVertexAttribIPointer, GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) +DO_GLFUNC(void, glTransformFeedbackVaryings, GLuint program, GLsizei count, const char* const* varyings, GLenum bufferMode) +DO_GLFUNC(void, glBeginTransformFeedback, GLenum primitivemode) +DO_GLFUNC(void, glEndTransformFeedback) +DO_GLFUNC(void, glFlushMappedBufferRange, GLenum target, GLintptr offset, GLsizeiptr length) +DO_GLFUNC(void, glGenVertexArrays, GLsizei n, GLuint* arrays) +DO_GLFUNC(void, glDeleteVertexArrays, GLsizei n, const GLuint* arrays) +DO_GLFUNC(void, glBindVertexArray, GLuint array) + +#undef DO_GLFUNC +#undef STRINGIFY +#undef STRINGIFY2 + +#endif +static void ClearFixedFunctionPrograms(); + +// \todo [2013-04-16 pyry] UtilsGLES30 or similar for these? + +static int queryInt (UInt32 pname) +{ + int value = 0; + GLES_CHK(glGetIntegerv(pname, &value)); + return value; +} + +// let's play safe here: +// ios/glesemu works just fine +// and shadows demands more careful eps choice - do it later +#define WORKAROUND_POLYGON_OFFSET UNITY_ANDROID + +// forward declarations + +namespace ShaderLab { + TexEnv* GetTexEnvForBinding( const TextureBinding& binding, const PropertySheet* props ); // pass.cpp +} + +// local forward declarations +struct DeviceStateGLES30; +static void ApplyBackfaceMode( const DeviceStateGLES30& state ); + +static FramebufferObjectManagerGLES30& GetFBOManager (DeviceStateGLES30& deviceState); + +// NOTE: GLES3.0 supports only 4 lights for now +enum { kMaxSupportedVertexLightsByGLES30 = 4 }; + +// Constant tables +static const unsigned int kBlendModeES2[] = { + GL_ZERO, GL_ONE, GL_DST_COLOR, GL_SRC_COLOR, GL_ONE_MINUS_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_COLOR, + GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_SRC_ALPHA_SATURATE, GL_ONE_MINUS_SRC_ALPHA, +}; + +static const unsigned int kBlendFuncES2[] = { + GL_FUNC_ADD, GL_FUNC_SUBTRACT, + GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX, +}; + +static const unsigned int kCmpFuncES2[] = { + GL_NEVER, GL_NEVER, GL_LESS, GL_EQUAL, GL_LEQUAL, GL_GREATER, GL_NOTEQUAL, GL_GEQUAL, GL_ALWAYS +}; + +static const unsigned int kStencilOpES2[] = { + GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, + GL_DECR, GL_INVERT, GL_INCR_WRAP, GL_DECR_WRAP +}; + +static const GLenum kWrapModeES2[kTexWrapCount] = { + GL_REPEAT, + GL_CLAMP_TO_EDGE, +}; + +static const GLenum kGLES30TextureDimensionTable[kTexDimCount] = {0, -1/*GL_TEXTURE_1D*/, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP, 0}; + +static const GLint kMinFilterES2[kTexFilterCount] = { GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR }; + +// -------------------------------------------------------------------------- + +struct DeviceDepthStateGLES30 : public DeviceDepthState +{ + UInt32 depthFunc; +}; + +struct DeviceStencilStateGLES30 : public DeviceStencilState +{ + GLenum stencilFuncFront; + GLenum stencilFailOpFront; + GLenum depthFailOpFront; + GLenum depthPassOpFront; + GLenum stencilFuncBack; + GLenum stencilFailOpBack; + GLenum depthFailOpBack; + GLenum depthPassOpBack; +}; + + +typedef std::map< GfxBlendState, DeviceBlendState, memcmp_less<GfxBlendState> > CachedBlendStates; +typedef std::map< GfxDepthState, DeviceDepthStateGLES30, memcmp_less<GfxDepthState> > CachedDepthStates; +typedef std::map< GfxStencilState, DeviceStencilStateGLES30, memcmp_less<GfxStencilState> > CachedStencilStates; +typedef std::map< GfxRasterState, DeviceRasterState, memcmp_less<GfxRasterState> > CachedRasterStates; + +// -------------------------------------------------------------------------- +struct TextureUnitStateGLES3 +{ + GLuint texID; + TextureDimension texDim; + unsigned int combColor, combAlpha; + Vector4f color; + TexGenMode texGen; + Matrix4x4f textureMatrix; + float bias; + + // right let waste space here instead of device-level int + bool identityMatrix; + bool isProjected; + bool posForTexGen; + bool nrmForTexGen; + + void Invalidate(); + + static bool PositionRequiredForTexGen(TexGenMode mode) + { + return (mode == kTexGenObject || mode == kTexGenEyeLinear); + } + + static bool NormalRequiredForTexGen(TexGenMode mode) + { + return (mode == kTexGenSphereMap || mode == kTexGenCubeReflect || mode == kTexGenCubeNormal); + } + + void SetTexGen( TexGenMode mode ) + { + posForTexGen = PositionRequiredForTexGen(mode); + nrmForTexGen = NormalRequiredForTexGen(mode); + + texGen = mode; + } +}; + +void TextureUnitStateGLES3::Invalidate() +{ + texID = -1; + texDim = kTexDimNone; + combColor = combAlpha = 0xFFFFFFFF; + color.Set( -1, -1, -1, -1 ); + texGen = kTexGenUnknown; + posForTexGen = 0; + nrmForTexGen = 0; + textureMatrix.SetIdentity(); + identityMatrix = true; + isProjected = false; + bias = 1.0e6f; +} + + +// -------------------------------------------------------------------------- +// TODO: optimize this. Right now we just send off whole 8 float3 UVs with each +// immediate mode vertex. We could at least detect the number of them used from +// ImmediateTexCoord calls. +struct ImmediateVertexGLES30 { + Vector3f vertex; + Vector3f normal; + UInt32 color; + Vector3f texCoords[8]; +}; + +struct ImmediateModeGLES30 { + std::vector<ImmediateVertexGLES30> m_Vertices; + ImmediateVertexGLES30 m_Current; + GfxPrimitiveType m_Mode; + + DataBufferGLES30* m_IndexBufferQuads; + + ImmediateModeGLES30(); + ~ImmediateModeGLES30(); + void Invalidate(); +}; + +// -------------------------------------------------------------------------- +struct DeviceStateGLES30 +{ + int m_TextureIDGenerator; + + int depthFunc; + int depthWrite; // 0/1 or -1 + + int blending; + int srcBlend, destBlend, srcBlendAlpha, destBlendAlpha; // Blend modes + int blendOp, blendOpAlpha; + CompareFunction alphaTest; + float alphaValue; + + CullMode culling; + bool appBackfaceMode, userBackfaceMode; + NormalizationMode + normalization; + int scissor; + + bool lighting; + bool separateSpecular; + SimpleVec4 matDiffuse, matAmbient, matSpecular, matEmissive; + SimpleVec4 ambient; + float matShininess; + ColorMaterialMode + colorMaterial; + + float offsetFactor, offsetUnits; + + int colorWriteMask; // ColorWriteMask combinations + SimpleVec4 color; + + TextureUnitStateGLES3 + textures[kMaxSupportedTextureUnitsGLES]; + int textureCount; + int activeTextureUnit; + + // pure optimization: texGen is very special case and is used sparingly + UInt32 positionTexGen; + UInt32 normalTexGen; + + int vertexLightCount; + LightType vertexLightTypes[kMaxSupportedVertexLights]; + + TransformState transformState; + + ConstantBuffersGLES30 + m_CBs; + + DynamicVBO* m_DynamicVBO; + bool vboContainsColor; + + int viewport[4]; + int scissorRect[4]; + + + GpuProgram* activeProgram; + const GpuProgramParameters* activeProgramParams; + dynamic_array<UInt8> activeProgramParamsBuffer; + UInt32 activeProgramID; + + + CachedBlendStates m_CachedBlendStates; + CachedDepthStates m_CachedDepthStates; + CachedStencilStates m_CachedStencilStates; + CachedRasterStates m_CachedRasterStates; + + const DeviceBlendState* m_CurrBlendState; + const DeviceDepthStateGLES30* m_CurrDepthState; + const DeviceStencilStateGLES30* m_CurrStencilState; + int m_StencilRef; + const DeviceRasterState* m_CurrRasterState; + + MaterialPropertyBlock m_MaterialProperties; + ImmediateModeGLES30 m_Imm; + + // Framebuffer objects. + FramebufferObjectManagerGLES30* m_fboManager; + FramebufferObjectGLES30* m_activeFbo; //!< Currently bound FBO. + FramebufferObjectGLES30* m_defaultFbo; //!< Default render target FBO or null if using default framebuffer (0). + +public: + DeviceStateGLES30(); + void Invalidate(); + void ComputeFixedFunctionState(FixedFunctionStateGLES30& state, const GfxFogParams& fog) const; + + inline void ApplyTexGen( UInt32 unit ); + inline void DropTexGen( UInt32 unit ); +}; + +DeviceStateGLES30::DeviceStateGLES30() +: m_DynamicVBO(0) +, m_fboManager(0) +, m_activeFbo (0) +, m_defaultFbo(0) +{ + m_TextureIDGenerator = 0; +} + +void DeviceStateGLES30::Invalidate() +{ + DBG_LOG_GLES30("Invalidate"); + int i; + + depthFunc = -1; //unknown + depthWrite = -1; + + blending = -1; // unknown + srcBlend = destBlend = -1; // won't match any GL mode + blendOp = blendOpAlpha = -1; + alphaTest = kFuncUnknown; + alphaValue = -1.0f; + + culling = kCullUnknown; + normalization = kNormalizationUnknown; + scissor = -1; + + lighting = false; + separateSpecular = false; + + matDiffuse.set( -1, -1, -1, -1 ); + matAmbient.set( -1, -1, -1, -1 ); + matSpecular.set( -1, -1, -1, -1 ); + matEmissive.set( -1, -1, -1, -1 ); + ambient.set( -1, -1, -1, -1 ); + matShininess = -1.0f; + colorMaterial = kColorMatUnknown; + + offsetFactor = offsetUnits = -1000.0f; + + colorWriteMask = -1; // TBD ? + m_StencilRef = -1; + + color.set( -1, -1, -1, -1 ); + + activeTextureUnit = -1; + for( i = 0; i < kMaxSupportedTextureUnitsGLES; ++i ) + textures[i].Invalidate(); + textureCount = 0; + + positionTexGen = 0; + normalTexGen = 0; + + vertexLightCount = 0; + for ( i = 0; i < kMaxSupportedVertexLights; ++i) + vertexLightTypes[i] = kLightDirectional; + + // make sure backface mode is in sync + appBackfaceMode = false; + userBackfaceMode = false; + ApplyBackfaceMode( *this ); + + vboContainsColor = true; + + viewport[0] = 0; + viewport[1] = 0; + viewport[2] = 0; + viewport[3] = 0; + + scissorRect[0] = 0; + scissorRect[1] = 0; + scissorRect[2] = 0; + scissorRect[3] = 0; + + activeProgram = 0; + activeProgramParams = 0; + activeProgramParamsBuffer.resize_uninitialized(0); + activeProgramID = -1; + + m_Imm.Invalidate(); + + m_activeFbo = 0; + + InvalidateVertexInputCacheGLES30(); + + GLESAssert(); +} + +void DeviceStateGLES30::ComputeFixedFunctionState(FixedFunctionStateGLES30& state, const GfxFogParams& fog) const +{ + if (lighting) + { + int numLights = vertexLightCount; + bool onlyDir = true; + for(int i = 0 ; i < numLights ; ++i) + { + onlyDir = onlyDir && (vertexLightTypes[i] == kLightDirectional); + state.SetLightType(i,vertexLightTypes[i]); + } + + state.lightingEnabled = true; + state.lightCount = numLights; + state.onlyDirectionalLights = onlyDir; + state.specularEnabled = separateSpecular; + + switch (colorMaterial) + { + case kColorMatDisabled: + break; + + case kColorMatAmbientAndDiffuse: + state.useVertexColorAsAmbientAndDiffuse = true; + break; + + case kColorMatEmission: + state.useVertexColorAsEmission = true; + break; + + default: + ErrorString("Unsupported color material mode"); + break; + } + } + else + { + state.lightingEnabled = false; + state.lightCount = 0; + } + + state.useUniformInsteadOfVertexColor = !vboContainsColor; + state.texUnitCount = textureCount; + + for (int i = 0; i < textureCount; i++) + { + Assert(textures[i].texDim != kTexDimUnknown); + Assert(textures[i].texDim != kTexDimNone); + Assert(textures[i].texDim != kTexDimAny); + Assert(textures[i].texDim != kTexDim3D); // OpenGLES3.0 does NOT supports 3D textures + state.texUnitCube[i] = (textures[i].texDim == kTexDimCUBE); + state.texUnitColorCombiner[i] = textures[i].combColor, + state.texUnitAlphaCombiner[i] = textures[i].combAlpha; + state.texUnitGen[i] = textures[i].texGen; + + bool needMatrix = !textures[i].identityMatrix || textures[i].texGen > kTexGenDisabled; + state.SetTexUnitMatrixParam(i, needMatrix, textures[i].isProjected); + } + + state.fogMode = fog.mode; + switch (fog.mode) + { + case kFogUnknown: + case kFogDisabled: + state.fogMode = kFogDisabled; + default: + break; + } + + if(gGraphicsCaps.gles30.hasAlphaTestQCOM) + { + // we dont want to generate special shader if we have alpha-test done gl style + state.alphaTest = kFuncDisabled; + } + else + { + state.alphaTest = alphaTest; + switch (alphaTest) + { + case kFuncNever: + /* \todo Disable drawing. */ + break; + case kFuncUnknown: + case kFuncDisabled: + case kFuncAlways: + state.alphaTest = kFuncDisabled; + default: + break; + } + } +} + +inline void DeviceStateGLES30::ApplyTexGen( UInt32 unit ) +{ + const TextureUnitStateGLES3& state = textures[unit]; + + positionTexGen = state.posForTexGen ? positionTexGen | (1<<unit) + : positionTexGen & ~(1<<unit); + + normalTexGen = state.nrmForTexGen ? normalTexGen | (1<<unit) + : normalTexGen & ~(1<<unit); +} + +inline void DeviceStateGLES30::DropTexGen( UInt32 unit ) +{ + positionTexGen &= ~(1<<unit); + normalTexGen &= ~(1<<unit); +} + + +#include "GfxDeviceGLES30.h" +#include "Runtime/GfxDevice/GLESCommon.h" + +void GfxDeviceGLES30_MarkWorldViewProjDirty() +{ + GFX_GL_IMPL& device = static_cast<GFX_GL_IMPL&>(GetRealGfxDevice()); + GetGLES30DeviceState(device).transformState.dirtyFlags |= TransformState::kWorldViewProjDirty; +} + +void GfxDeviceGLES30_DisableDepthTest() +{ + GFX_GL_IMPL& device = static_cast<GFX_GL_IMPL&>(GetRealGfxDevice()); + GetGLES30DeviceState(device).depthFunc = GL_NEVER; + GLES_CHK(glDisable(GL_DEPTH_TEST)); +} + +void GraphicsCaps::InitGLES30() +{ + // \todo [2013-04-16 pyry] Requires some serious cleanaup: + // - This functions shouldn't be member of GraphicsCaps (why it is?) + // - query extensions once, split to set and check from there + // - nicer wrapper for int caps queries + + GLES_InitCommonCaps(this); + gGles3ExtFunc.InitExtFunc(); + + shaderCaps = kShaderLevel3; + + maxLights = kMaxSupportedVertexLightsByGLES30; // vertex light count + hasAnisoFilter = QueryExtension("GL_EXT_texture_filter_anisotropic"); // has anisotropic filtering? + if (hasAnisoFilter) + GLES_CHK(glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, (GLint *)&maxAnisoLevel)); + else + maxAnisoLevel = 1; + + maxTexImageUnits = 8; + GLES_CHK(glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTexImageUnits)); + maxTexImageUnits = std::max<int>(std::min<int>( maxTexImageUnits, kMaxSupportedTextureUnitsGLES ), 1); + + maxTexUnits = maxTexImageUnits; + maxTexCoords = maxTexImageUnits; + maxMRTs = std::min<int>(FramebufferAttachmentsGLES30::kMaxColorAttachments, queryInt(GL_MAX_COLOR_ATTACHMENTS)); + + GLES_CHK(glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize)); + GLES_CHK(glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE, &maxCubeMapSize)); + GLES_CHK(glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE, &maxRenderTextureSize)); + + hasMipLevelBias = true; + hasMipMaxLevel = true; + + hasMultiSampleAutoResolve = false; // ES3 requires explicit glBlitFramebuffer() to do resolve. This affects how RenderTexture behaves. + hasMultiSample = true; + + hasBlendSquare = true; + hasSeparateAlphaBlend = true; + hasBlendSub = true; + hasBlendMinMax = true; + + hasS3TCCompression = false; + + hasAutoMipMapGeneration = false; // \todo [2013-04-16 pyry] glGenMipmap() does exist + + has3DTexture = false; // \todo [2013-04-16 pyry] Expose 3D textures + + npot = kNPOTFull; + npotRT = npot; + + hasRenderToTexture = true; + hasShadowCollectorPass = false; + + hasHighPrecisionTextureCombiners = false; // \todo [2013-04-16 pyry] Yep. We can use highp (fp32) in FS. Should be enough. + + hasRenderToCubemap = true; + + // \note supportsTextureFormat[N < kTexFormatPCCount] = true + + supportsTextureFormat[kTexFormatBGRA32] = QueryExtension("GL_APPLE_texture_format_BGRA8888"); + supportsTextureFormat[kTexFormatDXT1] = QueryExtension("GL_EXT_texture_compression_s3tc") || QueryExtension("GL_EXT_texture_compression_dxt1"); + supportsTextureFormat[kTexFormatDXT3] = QueryExtension("GL_EXT_texture_compression_s3tc") || QueryExtension("GL_CHROMIUM_texture_compression_dxt3"); + supportsTextureFormat[kTexFormatDXT5] = QueryExtension("GL_EXT_texture_compression_s3tc") || QueryExtension("GL_CHROMIUM_texture_compression_dxt5"); + supportsTextureFormat[kTexFormatPVRTC_RGB2] = QueryExtension("GL_IMG_texture_compression_pvrtc"); + supportsTextureFormat[kTexFormatPVRTC_RGBA2] = QueryExtension("GL_IMG_texture_compression_pvrtc"); + supportsTextureFormat[kTexFormatPVRTC_RGB4] = QueryExtension("GL_IMG_texture_compression_pvrtc"); + supportsTextureFormat[kTexFormatPVRTC_RGBA4] = QueryExtension("GL_IMG_texture_compression_pvrtc"); + supportsTextureFormat[kTexFormatATC_RGB4] = QueryExtension("GL_AMD_compressed_ATC_texture") || QueryExtension("GL_ATI_texture_compression_atitc"); + supportsTextureFormat[kTexFormatATC_RGBA8] = QueryExtension("GL_AMD_compressed_ATC_texture") || QueryExtension("GL_ATI_texture_compression_atitc"); + + supportsTextureFormat[kTexFormatETC_RGB4] = true; // \note Mapped to ETC2. + supportsTextureFormat[kTexFormatEAC_R] = true; + supportsTextureFormat[kTexFormatEAC_R_SIGNED] = true; + supportsTextureFormat[kTexFormatEAC_RG] = true; + supportsTextureFormat[kTexFormatEAC_RG_SIGNED] = true; + supportsTextureFormat[kTexFormatETC2_RGB] = true; + supportsTextureFormat[kTexFormatETC2_RGBA1] = true; + supportsTextureFormat[kTexFormatETC2_RGBA8] = true; + + const bool supportsASTC = QueryExtension("GL_KHR_texture_compression_astc_ldr"); + for(int loop = kTexFormatASTC_RGB_4x4; loop <= kTexFormatASTC_RGBA_12x12; loop++) + supportsTextureFormat[loop] = supportsASTC; + + // \todo [2013-04-16 pyry] Support means nothing until we can expose these to shaders as well. + // It requires changes to shader translator. + supportsRenderTextureFormat[kRTFormatARGB32] = true; + supportsRenderTextureFormat[kRTFormatDepth] = true; + supportsRenderTextureFormat[kRTFormatShadowMap] = true; + supportsRenderTextureFormat[kRTFormatRGB565] = true; + supportsRenderTextureFormat[kRTFormatARGB4444] = true; + supportsRenderTextureFormat[kRTFormatARGB1555] = true; + supportsRenderTextureFormat[kRTFormatDefault] = true; + supportsRenderTextureFormat[kRTFormatA2R10G10B10] = true; + supportsRenderTextureFormat[kRTFormatARGB64] = false; + supportsRenderTextureFormat[kRTFormatR8] = true; + supportsRenderTextureFormat[kRTFormatARGBInt] = true; + supportsRenderTextureFormat[kRTFormatRGInt] = true; + supportsRenderTextureFormat[kRTFormatRInt] = true; + + if (QueryExtension("GL_EXT_color_buffer_float")) + { + // Support for fp render targets was stripped from spec as last minute decision. Sigh.. + supportsRenderTextureFormat[kRTFormatARGBHalf] = true; + supportsRenderTextureFormat[kRTFormatRGHalf] = true; + supportsRenderTextureFormat[kRTFormatRHalf] = true; + + supportsRenderTextureFormat[kRTFormatARGBFloat] = true; + supportsRenderTextureFormat[kRTFormatRGFloat] = true; + supportsRenderTextureFormat[kRTFormatRFloat] = true; + + supportsRenderTextureFormat[kRTFormatDefaultHDR] = true; // ES3 backend uses R11F_G11F_B10F as default HDR format + } + + const bool isPvrGpu = (rendererString.find("PowerVR") != string::npos); + const bool isMaliGpu = (rendererString.find("Mali") != string::npos); + const bool isAdrenoGpu = (rendererString.find("Adreno") != string::npos); + const bool isTegraGpu = (rendererString.find("Tegra") != string::npos); + + hasNativeDepthTexture = true; + hasNativeShadowMap = true; + + hasRenderTargetStencil = true; + hasTwoSidedStencil = true; + hasStencilInDepthTexture = true; + hasStencil = true; + + has16BitFloatVertex = true; + needsToSwizzleVertexColors = false; + + hasSRGBReadWrite = false; // \todo [2013-06-05 pyry] Doesn't function properly + + disableSoftShadows = false; + buggyCameraRenderToCubemap = false; + + hasShadowCollectorPass = false; + + // Timer queries + gGraphicsCaps.hasTimerQuery = QueryExtension("GL_NV_timer_query"); + + // GLES3-specific variables. + gles30.maxAttributes = std::min<int>(kGLES3MaxVertexAttribs, queryInt(GL_MAX_VERTEX_ATTRIBS)); + gles30.maxVaryings = queryInt(GL_MAX_VARYING_VECTORS); + gles30.maxSamples = queryInt(GL_MAX_SAMPLES); + + hasTiledGPU = isPvrGpu || isAdrenoGpu || isMaliGpu; + + const bool isAdreno330 = (rendererString.find("Adreno (TM) 330") != string::npos); // MSM8974 dev device, with rather unstable drivers. + const bool isMali628 = (rendererString.find("Mali-T628") != string::npos); // ARM TG4 dev device, mapbuffer broken. + const bool isGLESEmu = (rendererString.find("Mali OpenGL ES Emulator") != string::npos); // ARM OpenGL ES 3.0 emulator, glGetProgramBinary broken + + gles30.useMapBuffer = true; + if(isAdrenoGpu || !isAdreno330) + gles30.useMapBuffer = false; // Buffer mapping is dead-slow on Adreno, but using BufferData() is broken on Adreno 330 + + if(isMali628) + gles30.useMapBuffer = false; // Mapbuffer broken on TG4 + + gles30.useProgramBinary = true; // Set true first, check actual support in Init call below. + gles30.useProgramBinary = GlslGpuProgramGLES30::InitBinaryShadersSupport(); + + + gles30.useTFSkinning = true; // TF skinning used to be broken on adreno, worked around now. + + + // \todo [2013-04-17 pyry] Extension queries. + + // \todo [2013-04-16 pyry] Figure out which gles20 flags make sense for ES3 as well. + + // \todo [2013-04-16 pyry] Why init timer queries here? +#if ENABLE_PROFILER + g_TimerQueriesGLES30.Init(); +#endif +} + +GfxDevice* CreateGLES30GfxDevice() +{ +#if UNITY_WIN || UNITY_LINUX || UNITY_BB10 || UNITY_ANDROID + InitializeGLES30(); +#endif + + gGraphicsCaps.InitGLES30(); + +#if UNITY_EDITOR + return NULL; +#else + return UNITY_NEW_AS_ROOT(GFX_GL_IMPL(), kMemGfxDevice, "GLES30GfxDevice",""); +#endif +} + +GFX_GL_IMPL::GFX_GL_IMPL() +{ + printf_console("Creating OpenGL ES 3.0 graphics device\n"); + #if !GFX_DEVICE_VIRTUAL + impl = new GfxDeviceImpl(); + #endif + + OnCreate(); + InvalidateState(); + m_Renderer = kGfxRendererOpenGLES30; + m_IsThreadable = true; + + m_UsesOpenGLTextureCoords = true; + m_UsesHalfTexelOffset = false; + + STATE.m_CurrBlendState = NULL; + STATE.m_CurrDepthState = NULL; + STATE.m_CurrStencilState = NULL; + STATE.m_CurrRasterState = NULL; + + extern RenderSurfaceBase* CreateBackBufferColorSurfaceGLES3(); + SetBackBufferColorSurface(CreateBackBufferColorSurfaceGLES3()); + + extern RenderSurfaceBase* CreateBackBufferDepthSurfaceGLES3(); + SetBackBufferDepthSurface(CreateBackBufferDepthSurfaceGLES3()); +} + +GFX_GL_IMPL::~GFX_GL_IMPL() +{ + TransformFeedbackSkinningInfo::CleanupTransformFeedbackShaders(); + ClearFixedFunctionPrograms(); + STATE.m_CBs.Clear(); + delete STATE.m_DynamicVBO; + delete STATE.m_fboManager; + + #if !GFX_DEVICE_VIRTUAL + delete impl; + #endif +#if UNITY_WIN || UNITY_ANDROID + ShutdownGLES30(); +#endif +} + +static void ActivateTextureUnitGLES3 (DeviceStateGLES30& state, int unit) +{ + if (state.activeTextureUnit == unit) + return; + GLES_CHK(glActiveTexture(GL_TEXTURE0 + unit)); + state.activeTextureUnit = unit; +} + +void GFX_GL_IMPL::InvalidateState() +{ + DBG_LOG_GLES30("InvalidateState"); + m_FogParams.Invalidate(); + STATE.transformState.Invalidate(m_BuiltinParamValues); + STATE.Invalidate(); + + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatEmission, Vector4f(1,1,1,1)); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatAmbient, Vector4f(1,1,1,1)); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatDiffuse, Vector4f(1,1,1,1)); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatSpecular, Vector4f(1,1,1,1)); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatShininess, Vector4f(1,1,1,1)); + + m_BuiltinParamValues.SetVectorParam(kShaderVecFFFogColor, Vector4f(0,0,0,0)); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFFogParams, Vector4f(0,0,0,0)); + + m_BuiltinParamValues.SetVectorParam(kShaderVecFFAlphaTestRef, Vector4f(0,0,0,0)); + + m_BuiltinParamValues.SetVectorParam(kShaderVecFFColor, Vector4f(1,1,1,1)); + for (int i = 0; i < kMaxSupportedTextureUnitsGLES; i++) + m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecFFTextureEnvColor0+i), Vector4f(0,0,0,0)); +} + +DeviceBlendState* GFX_GL_IMPL::CreateBlendState(const GfxBlendState& state) +{ + std::pair<CachedBlendStates::iterator, bool> result = STATE.m_CachedBlendStates.insert(std::make_pair(state, DeviceBlendState())); + if (!result.second) + return &result.first->second; + + DeviceBlendState& glstate = result.first->second; + memcpy(&glstate.sourceState, &state, sizeof(glstate.sourceState)); + DebugAssertIf(kFuncUnknown==state.alphaTest); + + return &result.first->second; +} + +DeviceDepthState* GFX_GL_IMPL::CreateDepthState(const GfxDepthState& state) +{ + std::pair<CachedDepthStates::iterator, bool> result = STATE.m_CachedDepthStates.insert(std::make_pair(state, DeviceDepthStateGLES30())); + if (!result.second) + return &result.first->second; + + DeviceDepthStateGLES30& glstate = result.first->second; + memcpy(&glstate.sourceState, &state, sizeof(glstate.sourceState)); + glstate.depthFunc = kCmpFuncES2[state.depthFunc]; + return &result.first->second; +} + +DeviceStencilState* GFX_GL_IMPL::CreateStencilState(const GfxStencilState& state) +{ + std::pair<CachedStencilStates::iterator, bool> result = STATE.m_CachedStencilStates.insert(std::make_pair(state, DeviceStencilStateGLES30())); + if (!result.second) + return &result.first->second; + + DeviceStencilStateGLES30& st = result.first->second; + memcpy (&st.sourceState, &state, sizeof(st.sourceState)); + st.stencilFuncFront = kCmpFuncES2[state.stencilFuncFront]; + st.stencilFailOpFront = kStencilOpES2[state.stencilFailOpFront]; + st.depthFailOpFront = kStencilOpES2[state.stencilZFailOpFront]; + st.depthPassOpFront = kStencilOpES2[state.stencilPassOpFront]; + st.stencilFuncBack = kCmpFuncES2[state.stencilFuncBack]; + st.stencilFailOpBack = kStencilOpES2[state.stencilFailOpBack]; + st.depthFailOpBack = kStencilOpES2[state.stencilZFailOpBack]; + st.depthPassOpBack = kStencilOpES2[state.stencilPassOpBack]; + return &result.first->second; +} + +DeviceRasterState* GFX_GL_IMPL::CreateRasterState(const GfxRasterState& state) +{ + std::pair<CachedRasterStates::iterator, bool> result = STATE.m_CachedRasterStates.insert(std::make_pair(state, DeviceRasterState())); + if (!result.second) + return &result.first->second; + + DeviceRasterState& glstate = result.first->second; + memcpy(&glstate.sourceState, &state, sizeof(glstate.sourceState)); + + return &result.first->second; +} + +void GFX_GL_IMPL::SetBlendState(const DeviceBlendState* state, float alphaRef) +{ + DeviceBlendState* devstate = (DeviceBlendState*)state; + + if (STATE.m_CurrBlendState == devstate && alphaRef == STATE.alphaValue) + return; + + STATE.m_CurrBlendState = devstate; + if (!STATE.m_CurrBlendState) + return; + + const GfxBlendState& desc = state->sourceState; + const GLenum glsrc = kBlendModeES2[desc.srcBlend]; + const GLenum gldst = kBlendModeES2[desc.dstBlend]; + const GLenum glsrca = kBlendModeES2[desc.srcBlendAlpha]; + const GLenum gldsta = kBlendModeES2[desc.dstBlendAlpha]; + const GLenum glfunc = kBlendFuncES2[desc.blendOp]; + const GLenum glfunca = kBlendFuncES2[desc.blendOpAlpha]; + const bool blendDisabled = (glsrc == GL_ONE && gldst == GL_ZERO && glsrca == GL_ONE && gldsta == GL_ZERO); + + int mask = devstate->sourceState.renderTargetWriteMask; + if (STATE.m_activeFbo && STATE.m_activeFbo->GetNumColorAttachments() == 0) + mask = 0; + + if( mask != STATE.colorWriteMask ) + { + GLES_CHK(glColorMask( (mask & kColorWriteR) != 0, (mask & kColorWriteG) != 0, (mask & kColorWriteB) != 0, (mask & kColorWriteA) != 0 )); + STATE.colorWriteMask = mask; + } + + if( blendDisabled ) + { + if( STATE.blending != 0 ) + { + GLES_CHK(glDisable (GL_BLEND)); + STATE.blending = 0; + } + } + else + { + if( glsrc != STATE.srcBlend || gldst != STATE.destBlend || glsrca != STATE.srcBlendAlpha || gldsta != STATE.destBlendAlpha ) + { + GLES_CHK(glBlendFuncSeparate(glsrc, gldst, glsrca, gldsta)); + STATE.srcBlend = glsrc; + STATE.destBlend = gldst; + STATE.srcBlendAlpha = glsrca; + STATE.destBlendAlpha = gldsta; + } + if (glfunc != STATE.blendOp || glfunca != STATE.blendOpAlpha) + { + GLES_CHK(glBlendEquationSeparate(glfunc, glfunca)); + STATE.blendOp = glfunc; + STATE.blendOpAlpha = glfunca; + } + if( STATE.blending != 1 ) + { + GLES_CHK(glEnable( GL_BLEND )); + STATE.blending = 1; + } + } + // fragment shader is expected to implement per fragment culling + CompareFunction alphaTest = devstate->sourceState.alphaTest; + + // \todo [2013-04-16 pyry] Alpha testing should be moved to shaders + + if (gGraphicsCaps.gles30.hasAlphaTestQCOM && (alphaTest != STATE.alphaTest || alphaRef != STATE.alphaValue)) + { + if (alphaTest != kFuncDisabled) + { + GLES_CHK(gGles3ExtFunc.glAlphaFuncQCOM(kCmpFuncES2[alphaTest], alphaRef)); + GLES_CHK(glEnable(GL_ALPHA_TEST_QCOM)); + } + else + { + GLES_CHK(glDisable(GL_ALPHA_TEST_QCOM)); + } + } + + STATE.alphaTest = alphaTest; + STATE.alphaValue = alphaRef; +} + +void GFX_GL_IMPL::SetRasterState(const DeviceRasterState* state) +{ + DeviceRasterState* devstate = (DeviceRasterState*)state; + if(!devstate) + { + STATE.m_CurrRasterState = NULL; + return; + } + + STATE.m_CurrRasterState = devstate; + + CullMode cull = devstate->sourceState.cullMode; + if( cull != STATE.culling ) + { + switch (cull) { + case kCullOff: + GLES_CHK(glDisable (GL_CULL_FACE)); + break; + case kCullFront: + GLES_CHK(glCullFace (GL_FRONT)); + GLES_CHK(glEnable (GL_CULL_FACE)); + break; + case kCullBack: + GLES_CHK(glCullFace (GL_BACK)); + GLES_CHK(glEnable (GL_CULL_FACE)); + break; + default: + break; + } + STATE.culling = cull; + } + + float zFactor = devstate->sourceState.slopeScaledDepthBias; + float zUnits = devstate->sourceState.depthBias; + if( zFactor != STATE.offsetFactor || zUnits != STATE.offsetUnits ) + { + +#if WORKAROUND_POLYGON_OFFSET + // on some androids polygon offset work the other way (positive push to viewer) + // so we tweak projection matrix to do offset + // also use available depth precision better (on Adreno for example fix bugs with z-fighting) + // Game Programming Gems Vol1 + // Eric Lengyel's "Tweaking a Vertex's Projected Depth Value" + // we use simplified formula: just smallest possible eps directly (multiplied by zUnits) + // we calculate eps for 16bit depth (good enough for larger depth) + // in projection matrix [2,2] = (f+n)/(n-f) + // so eps would be BitsMult * -1/proj[2,2] + + static const float _BitsMult = -1.0f / (float)0xFFFF; // FFFF = 2^16-1, minus sign incorporated here + + float* matrixElem = &m_BuiltinParamValues.GetWritableMatrixParam(kShaderMatProj).Get(2,2); + + const float eps = _BitsMult / *matrixElem; + *matrixElem *= (1.0f + zUnits*eps); +#else + GLES_CHK(glPolygonOffset( zFactor, zUnits )); + if( zFactor || zUnits ) + GLES_CHK(glEnable (GL_POLYGON_OFFSET_FILL)); + else + GLES_CHK(glDisable (GL_POLYGON_OFFSET_FILL)); +#endif + STATE.offsetFactor = zFactor; + STATE.offsetUnits = zUnits; + } +} + + +void GFX_GL_IMPL::SetDepthState(const DeviceDepthState* state) +{ + DeviceDepthStateGLES30* devstate = (DeviceDepthStateGLES30*)state; + if (STATE.m_CurrDepthState == devstate) + return; + + STATE.m_CurrDepthState = devstate; + + if (!STATE.m_CurrDepthState) + return; + + const int depthFunc = devstate->depthFunc; + if( depthFunc != STATE.depthFunc ) + { + if( depthFunc != GL_NEVER ) { + GLES_CHK(glDepthFunc (depthFunc)); + GLES_CHK(glEnable (GL_DEPTH_TEST)); + } else { + GLES_CHK(glDisable (GL_DEPTH_TEST)); + } + + STATE.depthFunc = depthFunc; + } + + const int writeMode = devstate->sourceState.depthWrite ? GL_TRUE : GL_FALSE; + if( writeMode != STATE.depthWrite ) + { + GLES_CHK(glDepthMask (writeMode)); + STATE.depthWrite = writeMode; + } +} + +void GFX_GL_IMPL::SetStencilState (const DeviceStencilState* state, int stencilRef) +{ + if (STATE.m_CurrStencilState == state && STATE.m_StencilRef == stencilRef) + return; + const DeviceStencilStateGLES30* st = static_cast<const DeviceStencilStateGLES30*>(state); + STATE.m_CurrStencilState = st; + if (!st) + return; + + if (st->sourceState.stencilEnable) + GLES_CHK(glEnable (GL_STENCIL_TEST)); + else + GLES_CHK(glDisable (GL_STENCIL_TEST)); + if (gGraphicsCaps.hasTwoSidedStencil) + { + GLES_CHK(glStencilFuncSeparate (GL_FRONT, st->stencilFuncFront, stencilRef, st->sourceState.readMask)); + GLES_CHK(glStencilOpSeparate (GL_FRONT, st->stencilFailOpFront, st->depthFailOpFront, st->depthPassOpFront)); + GLES_CHK(glStencilFuncSeparate (GL_BACK, st->stencilFuncBack, stencilRef, st->sourceState.readMask)); + GLES_CHK(glStencilOpSeparate (GL_BACK, st->stencilFailOpBack, st->depthFailOpBack, st->depthPassOpBack)); + } + else + { + GLES_CHK(glStencilFunc (st->stencilFuncFront, stencilRef, st->sourceState.readMask)); + GLES_CHK(glStencilOp (st->stencilFailOpFront, st->depthFailOpFront, st->depthPassOpFront)); + } + GLES_CHK(glStencilMask (st->sourceState.writeMask)); + + STATE.m_StencilRef = stencilRef; +} + +void GFX_GL_IMPL::SetSRGBWrite (bool enable) +{ + // \todo [2013-04-16 pyry] Implement sRGB support: + // - In ES3 sRGB bit is tied to format and there is no way to create views with different format + // - This is used rather liberally from Camera + // -> Use sRGB FBO for emulation, and defer necessary blits until it is known whether they are needed + Assert("Not implemented"); +} + +bool GFX_GL_IMPL::GetSRGBWrite () +{ + return false; +} + +void GFX_GL_IMPL::Clear (UInt32 clearFlags, const float color[4], float depth, int stencil) +{ + DBG_LOG_GLES30("Clear(%d, (%.2f, %.2f, %.2f, %.2f), %.2f, %d", clearFlags, color[0], color[1], color[2], color[3], depth, stencil); + + // \todo [2013-04-16 pyry] Integer render targets require use of glClearBuffer() + // \todo [2013-04-29 pyry] Here was a call that restored FBO binding to default one. Why? + + if (STATE.m_activeFbo && STATE.m_activeFbo->GetNumColorAttachments() == 0) + clearFlags &= ~kGfxClearColor; + + // In OpenGL, clears are affected by color write mask and depth writing parameters. + // So make sure to set them! + GLbitfield flags = 0; + if (clearFlags & kGfxClearColor) + { + if (STATE.colorWriteMask != 15) + { + GLES_CHK(glColorMask( true, true, true, true )); + STATE.colorWriteMask = 15; + STATE.m_CurrBlendState = NULL; + } + flags |= GL_COLOR_BUFFER_BIT; + GLES_CHK(glClearColor( color[0], color[1], color[2], color[3] )); + } + if (clearFlags & kGfxClearDepth) + { + GLES_CHK(glDepthMask (GL_TRUE)); + STATE.depthWrite = GL_TRUE; + STATE.m_CurrDepthState = NULL; + flags |= GL_DEPTH_BUFFER_BIT; + GLES_CHK(glClearDepthf( depth )); + } + if (clearFlags & kGfxClearStencil) + { + //@TODO: need to set stencil writes on? + flags |= GL_STENCIL_BUFFER_BIT; + GLES_CHK(glClearStencil (stencil)); + } + GLES_CHK(glClear(flags)); +} + +static void ApplyBackfaceMode( const DeviceStateGLES30& state ) +{ + DBG_LOG_GLES30("ApplyBackfaceMode"); + if (state.appBackfaceMode != state.userBackfaceMode) + GLES_CHK(glFrontFace( GL_CCW )); + else + GLES_CHK(glFrontFace( GL_CW )); +} + +void GFX_GL_IMPL::SetUserBackfaceMode( bool enable ) +{ + DBG_LOG_GLES30("SetUserBackfaceMode(%s)", GetBoolString(enable)); + if( STATE.userBackfaceMode == enable ) + return; + + STATE.userBackfaceMode = enable; + ApplyBackfaceMode( STATE ); +} + +void GFX_GL_IMPL::SetInvertProjectionMatrix( bool enable ) +{ + Assert (!enable); // projection should never be flipped upside down on OpenGL +} + +bool GFX_GL_IMPL::GetInvertProjectionMatrix() const +{ + return false; +} + +void GFX_GL_IMPL::SetProjectionMatrix (const Matrix4x4f& matrix) +{ + DBG_LOG_GLES30("SetProjectionMatrix(...)"); + + CopyMatrix(matrix.GetPtr(), STATE.transformState.projectionMatrixOriginal.GetPtr()); + CopyMatrix (matrix.GetPtr(), m_BuiltinParamValues.GetWritableMatrixParam(kShaderMatProj).GetPtr()); + STATE.transformState.dirtyFlags |= TransformState::kProjDirty; +} + +void GFX_GL_IMPL::SetWorldMatrix( const float matrix[16] ) +{ + CopyMatrix( matrix, STATE.transformState.worldMatrix.GetPtr() ); + STATE.transformState.dirtyFlags |= TransformState::kWorldDirty; +} + +void GFX_GL_IMPL::SetViewMatrix( const float matrix[16] ) +{ + STATE.transformState.SetViewMatrix (matrix, m_BuiltinParamValues); +} + +void GFX_GL_IMPL::GetMatrix( float outMatrix[16] ) const +{ + STATE.transformState.UpdateWorldViewMatrix (m_BuiltinParamValues); + CopyMatrix (STATE.transformState.worldViewMatrix.GetPtr(), outMatrix); +} + +const float* GFX_GL_IMPL::GetWorldMatrix() const +{ + return STATE.transformState.worldMatrix.GetPtr(); +} + +const float* GFX_GL_IMPL::GetViewMatrix() const +{ + return m_BuiltinParamValues.GetMatrixParam(kShaderMatView).GetPtr(); +} + +const float* GFX_GL_IMPL::GetProjectionMatrix() const +{ + return STATE.transformState.projectionMatrixOriginal.GetPtr(); +} + +const float* GFX_GL_IMPL::GetDeviceProjectionMatrix() const +{ + return GetProjectionMatrix(); +} + +void GFX_GL_IMPL::SetNormalizationBackface( NormalizationMode mode, bool backface ) +{ + DBG_LOG_GLES30("SetNormalizationBackface(%d %s)", mode, backface?"back":"front"); + STATE.normalization = mode; + if( STATE.appBackfaceMode != backface ) + { + STATE.appBackfaceMode = backface; + ApplyBackfaceMode( STATE ); + } +} + +void GFX_GL_IMPL::SetFFLighting( bool on, bool separateSpecular, ColorMaterialMode colorMaterial ) +{ + DBG_LOG_GLES30("SetFFLighting(%s, %s, %d)", on?"True":"False", separateSpecular?"True":"False", colorMaterial); + STATE.lighting = on; + STATE.separateSpecular = separateSpecular; + STATE.colorMaterial = colorMaterial; +} + +void GFX_GL_IMPL::SetMaterial( const float ambient[4], const float diffuse[4], const float specular[4], const float emissive[4], const float shininess ) +{ + DBG_LOG_GLES30("SetMaterial()"); + STATE.matAmbient.set (ambient[0], ambient[1], ambient[2], 1.0F); + STATE.matDiffuse.set (diffuse); + STATE.matSpecular.set (specular[0], specular[1], specular[2], 1.0F); + STATE.matEmissive.set (emissive[0], emissive[1], emissive[2], 1.0F); + float glshine = std::max<float>(std::min<float>(shininess,1.0f), 0.0f) * 128.0f; + STATE.matShininess = glshine; +} + +void GFX_GL_IMPL::SetColor( const float color[4] ) +{ + DBG_LOG_GLES30("SetColor()"); + STATE.color.set( color ); + // Emulate OpenGL's behaviour + ImmediateColor( color[0], color[1], color[2], color[3] ); +} + +void GFX_GL_IMPL::SetViewport( int x, int y, int width, int height ) +{ + DBG_LOG_GLES30("SetViewport(%d, %d, %d, %d)", x, y, width, height); + STATE.viewport[0] = x; + STATE.viewport[1] = y; + STATE.viewport[2] = width; + STATE.viewport[3] = height; + GLES_CHK(glViewport( x, y, width, height )); +} + +void GFX_GL_IMPL::GetViewport( int* port ) const +{ + DBG_LOG_GLES30("GetViewport()"); + port[0] = STATE.viewport[0]; + port[1] = STATE.viewport[1]; + port[2] = STATE.viewport[2]; + port[3] = STATE.viewport[3]; +} + +void GFX_GL_IMPL::SetScissorRect( int x, int y, int width, int height ) +{ + DBG_LOG_GLES30("SetScissorRect(%d, %d, %d, %d)", x, y, width, height); + + if (STATE.scissor != 1) + { + GLES_CHK(glEnable( GL_SCISSOR_TEST )); + STATE.scissor = 1; + } + + STATE.scissorRect[0] = x; + STATE.scissorRect[1] = y; + STATE.scissorRect[2] = width; + STATE.scissorRect[3] = height; + GLES_CHK(glScissor( x, y, width, height )); + +} + +void GFX_GL_IMPL::DisableScissor() +{ + DBG_LOG_GLES30("DisableScissor()"); + if (STATE.scissor != 0) + { + GLES_CHK(glDisable( GL_SCISSOR_TEST )); + STATE.scissor = 0; + } +} + +bool GFX_GL_IMPL::IsScissorEnabled() const +{ + DBG_LOG_GLES30("IsScissorEnabled():returns %s", STATE.scissor == 1?"True":"False"); + return STATE.scissor == 1; +} + +void GFX_GL_IMPL::GetScissorRect( int scissor[4] ) const +{ + DBG_LOG_GLES30("GetScissorRect()"); + scissor[0] = STATE.scissorRect[0]; + scissor[1] = STATE.scissorRect[1]; + scissor[2] = STATE.scissorRect[2]; + scissor[3] = STATE.scissorRect[3]; +} +bool GFX_GL_IMPL::IsCombineModeSupported( unsigned int combiner ) +{ + return true; +} + +TextureCombinersHandle GFX_GL_IMPL::CreateTextureCombiners( int count, const ShaderLab::TextureBinding* texEnvs, const ShaderLab::PropertySheet* props, bool hasVertexColorOrLighting, bool usesAddSpecular ) +{ + DBG_LOG_GLES30("CreateTextureCombiners()"); + TextureCombinersGLES3* implGLES = TextureCombinersGLES3::Create (count, texEnvs); + return TextureCombinersHandle (implGLES); +} + +void GFX_GL_IMPL::DeleteTextureCombiners( TextureCombinersHandle& textureCombiners ) +{ + DBG_LOG_GLES30("DeleteTextureCombiners()"); + TextureCombinersGLES3* implGLES = OBJECT_FROM_HANDLE(textureCombiners, TextureCombinersGLES3); + delete implGLES; + textureCombiners.Reset(); +} + +void GFX_GL_IMPL::SetTextureCombiners( TextureCombinersHandle textureCombiners, const ShaderLab::PropertySheet* props ) +{ + DBG_LOG_GLES30("SetTextureCombiners()"); + TextureCombinersGLES3* implGLES = OBJECT_FROM_HANDLE(textureCombiners,TextureCombinersGLES3); + Assert (implGLES); + + const int count = std::min(gGraphicsCaps.maxTexUnits, implGLES->count); + // Fill in arrays + TexEnvData* texEnvData; + ALLOC_TEMP (texEnvData, TexEnvData, count); + for( int i = 0; i < count; ++i ) + { + ShaderLab::TexEnv *te = ShaderLab::GetTexEnvForBinding( implGLES->texEnvs[i], props ); + Assert( te != NULL ); + te->PrepareData (implGLES->texEnvs[i].m_TextureName.index, implGLES->texEnvs[i].m_MatrixName, props, &texEnvData[i]); + } + + Vector4f* texColors; + ALLOC_TEMP (texColors, Vector4f, implGLES->count); + for( int i = 0; i < implGLES->count; ++i ) + { + const ShaderLab::TextureBinding& binding = implGLES->texEnvs[i]; + texColors[i] = binding.GetTexColor().Get (props); + } + GFX_GL_IMPL::SetTextureCombinersThreadable(textureCombiners, texEnvData, texColors); + +} + + +void GFX_GL_IMPL::SetTextureCombinersThreadable( TextureCombinersHandle textureCombiners, const TexEnvData* texEnvData, const Vector4f* texColors ) +{ + DBG_LOG_GLES30("SetTextureCombiners()"); + TextureCombinersGLES3* implGLES = OBJECT_FROM_HANDLE(textureCombiners,TextureCombinersGLES3); + Assert (implGLES); + + const int count = std::min(gGraphicsCaps.maxTexUnits, implGLES->count); + STATE.textureCount = count; + for (int i = 0; i < count; ++i) + { + const ShaderLab::TextureBinding& binding = implGLES->texEnvs[i]; + + // set the texture + ApplyTexEnvData (i, i, texEnvData[i]); + + // setup texture unit state + TextureUnitStateGLES3& texUnitState = STATE.textures[i]; + texUnitState.color = texColors[i]; + texUnitState.combColor = binding.m_CombColor; + texUnitState.combAlpha = binding.m_CombAlpha; + } + // we can just create mask and "and" with it + // but consider me lazy + for( int i = count ; i < gGraphicsCaps.maxTexUnits ; ++i) + STATE.DropTexGen(i); + + STATE.activeProgram = 0; + + // Get us back to TU 0, so we know where we stand + ActivateTextureUnitGLES3 (STATE, 0); + +} + +void GFX_GL_IMPL::SetTexture (ShaderType shaderType, int unit, int samplerUnit, TextureID texture, TextureDimension dim, float bias) +{ + DBG_LOG_GLES30("SetTexture(%d %d)", unit, texture.m_ID); + DebugAssertIf( unit < 0 || unit >= gGraphicsCaps.maxTexUnits ); + + GLenum texType = kGLES30TextureDimensionTable[dim]; + GLuint targetTex = (GLuint)TextureIdMap::QueryNativeTexture(texture); + + if (texType == (GLenum)-1) + { + Assert("Not supported"); + return; + } + + // \todo [2013-04-16 pyry] Shouldn't we clear state still? + if (targetTex == 0) + return; + + TextureUnitStateGLES3& currTex = STATE.textures[unit]; + if (STATE.textureCount > unit && targetTex == currTex.texID) + return; // Already bound. + + ActivateTextureUnitGLES3 (STATE, unit); + + GLES_CHK(glBindTexture(texType, targetTex)); + + if (STATE.textureCount <= unit) + STATE.textureCount = unit+1; + currTex.texID = targetTex; + currTex.texDim = dim; + if (currTex.texGen == kTexGenUnknown) + currTex.texGen = kTexGenDisabled; + + STATE.ApplyTexGen(unit); + + GLESAssert(); + + // \todo [2013-04-16 pyry] Lod bias is given from shader. + if (bias != std::numeric_limits<float>::infinity()) + currTex.bias = bias; +} + +void GFX_GL_IMPL::SetTextureTransform( int unit, TextureDimension dim, TexGenMode texGen, bool identity, const float matrix[16]) +{ + DBG_LOG_GLES30("SetTextureTransform()"); + DebugAssertIf( unit < 0 || unit >= gGraphicsCaps.maxTexUnits ); + TextureUnitStateGLES3& unitState = STATE.textures[unit]; + + unitState.SetTexGen(texGen); + unitState.textureMatrix = *(Matrix4x4f const*)matrix; + + // Since we will set texture matrix even if TexGen is disabled (since matrix can contain scale/offset information) + // we set textureMatrix to identity to be on a safe side + if (identity) + unitState.textureMatrix.SetIdentity(); + unitState.identityMatrix = identity; + + unitState.isProjected = false; + if (!identity && dim==kTexDim2D) + unitState.isProjected = (matrix[3] != 0.0f || matrix[7] != 0.0f || matrix[11] != 0.0f || matrix[15] != 1.0f); + + STATE.ApplyTexGen(unit); +} + +void GFX_GL_IMPL::SetTextureParams( TextureID texture, TextureDimension texDim, TextureFilterMode filter, TextureWrapMode wrap, int anisoLevel, bool hasMipMap, TextureColorSpace colorSpace ) +{ + DBG_LOG_GLES30("SetTextureParams()"); + + TextureIdMapGLES30_QueryOrCreate(texture); + + GLuint target = kGLES30TextureDimensionTable[texDim]; + SetTexture (kShaderFragment, 0, 0, texture, texDim, std::numeric_limits<float>::infinity()); + + // Anisotropic texturing... + if( gGraphicsCaps.hasAnisoFilter ) + { + anisoLevel = std::min( anisoLevel, gGraphicsCaps.maxAnisoLevel ); + GLES_CHK(glTexParameteri( target, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisoLevel )); + } + + GLenum wrapMode = kWrapModeES2[wrap]; + GLES_CHK(glTexParameteri( target, GL_TEXTURE_WRAP_S, wrapMode )); + GLES_CHK(glTexParameteri( target, GL_TEXTURE_WRAP_T, wrapMode )); + + if( !hasMipMap && filter == kTexFilterTrilinear ) + filter = kTexFilterBilinear; + + GLES_CHK(glTexParameteri( target, GL_TEXTURE_MAG_FILTER, filter != kTexFilterNearest ? GL_LINEAR : GL_NEAREST )); + if( hasMipMap ) + GLES_CHK(glTexParameteri( target, GL_TEXTURE_MIN_FILTER, kMinFilterES2[filter] )); + else + GLES_CHK(glTexParameteri (target, GL_TEXTURE_MIN_FILTER, filter != kTexFilterNearest ? GL_LINEAR : GL_NEAREST)); + + GLESAssert(); +} + +void GFX_GL_IMPL::SetMaterialProperties( const MaterialPropertyBlock& block ) +{ + STATE.m_MaterialProperties = block; +} + +void GFX_GL_IMPL::SetShadersThreadable (GpuProgram* programs[kShaderTypeCount], const GpuProgramParameters* params[kShaderTypeCount], UInt8 const * const paramsBuffer[kShaderTypeCount]) +{ + GpuProgram* vertexProgram = programs[kShaderVertex]; + GpuProgram* fragmentProgram = programs[kShaderFragment]; + + DBG_LOG_GLES30("SetShaders(%s, %s)", + GetShaderImplTypeString(vertexProgram? vertexProgram->GetImplType():kShaderImplUndefined), + GetShaderImplTypeString(fragmentProgram? fragmentProgram->GetImplType():kShaderImplUndefined)); + + // GLSL is only supported like this: + // vertex shader actually is both vertex & fragment linked program + // fragment shader is unused + + if (vertexProgram && vertexProgram->GetImplType() == kShaderImplBoth) + { + Assert(fragmentProgram == 0 || fragmentProgram->GetImplType() == kShaderImplBoth); + STATE.activeProgram = vertexProgram; + STATE.activeProgramParams = params[kShaderVertex]; + DebugAssert(STATE.activeProgramParams->IsReady()); + int bufferSize = STATE.activeProgramParams->GetValuesSize(); + STATE.activeProgramParamsBuffer.resize_uninitialized(bufferSize); + memcpy(STATE.activeProgramParamsBuffer.data(), paramsBuffer[kShaderVertex], bufferSize); + } + else + { + Assert(vertexProgram == 0); + STATE.activeProgram = 0; + STATE.activeProgramParams = 0; + STATE.activeProgramParamsBuffer.resize_uninitialized(0); + } +} + +void GFX_GL_IMPL::CreateShaderParameters( ShaderLab::SubProgram* program, FogMode fogMode ) +{ + GlslGpuProgramGLES30& programGLES = static_cast<GlslGpuProgramGLES30&>(program->GetGpuProgram()); + programGLES.GetGLProgram(fogMode, program->GetParams(fogMode), program->GetChannels()); +} + +bool GFX_GL_IMPL::IsShaderActive( ShaderType type ) const +{ + //DBG_LOG_GLES30("IsShaderActive(%s): returns %s", GetShaderTypeString(type), STATE.shaderEnabledImpl[type] != kShaderImplUndefined?"True":"False"); + //return STATE.shaderEnabledImpl[type] != kShaderImplUndefined; + DBG_LOG_GLES30("IsShaderActive(%s):", GetShaderTypeString(type)); + return (STATE.activeProgram != 0); +} + +void GFX_GL_IMPL::DestroySubProgram( ShaderLab::SubProgram* subprogram ) +{ + //@TODO + //if (STATE.activeProgram == program) + //{ + // STATE.activeProgram = NULL; + // STATE.activeProgramProps = NULL; + //} + delete subprogram; +} + +void GFX_GL_IMPL::SetConstantBufferInfo( int id, int size ) +{ + STATE.m_CBs.SetCBInfo(id, size); +} + +void GFX_GL_IMPL::DisableLights( int startLight ) +{ + DBG_LOG_GLES30("DisableLights(%d)", startLight); + startLight = std::min (startLight, gGraphicsCaps.maxLights); + STATE.vertexLightCount = startLight; + for (int i = startLight; i < kMaxSupportedVertexLightsByGLES30; ++i) + { + m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Position + i), Vector4f(0.0f, 0.0f, 1.0f, 0.0f)); + m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Diffuse + i), Vector4f(0.0f, 0.0f, 0.0f, 0.0f)); + } +} + +void GFX_GL_IMPL::SetLight( int light, const GfxVertexLight& data) +{ + DBG_LOG_GLES30("SetLight(%d), [{%f, %f, %f, %f}, {%f, %f, %f, %f}, {%f, %f, %f, %f}, %f, %f, %f, %d]", + light, + data.position[0], data.position[1], data.position[2], data.position[3], + data.spotDirection[0], data.spotDirection[1], data.spotDirection[2], data.spotDirection[3], + data.color[0], data.color[1], data.color[2], data.color[3], + data.range, data.quadAtten, data.spotAngle, data.type); + Assert( light >= 0 && light < kMaxSupportedVertexLights ); + + if (light >= kMaxSupportedVertexLightsByGLES30) + return; + + STATE.vertexLightTypes[light] = data.type; + + // Transform lighting into view space + const Matrix4x4f& viewMat = m_BuiltinParamValues.GetMatrixParam(kShaderMatView); + + // spot direction + Vector4f& spotDirection = m_BuiltinParamValues.GetWritableVectorParam(BuiltinShaderVectorParam(kShaderVecLight0SpotDirection + light)); + if( data.spotAngle > 0.0f ) + { + Vector3f d = viewMat.MultiplyVector3( (const Vector3f&)data.spotDirection ); + spotDirection.Set(-d.x, -d.y, -d.z, 0.0f); + } + else + { + spotDirection.Set(0.0f, 0.0f, 1.0f, 0.0f); + } + + Vector4f& position = m_BuiltinParamValues.GetWritableVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Position + light)); + if (data.type == kLightDirectional) + { + Vector3f p = viewMat.MultiplyVector3( (const Vector3f&)data.position ); + position.Set(-p.x, -p.y, -p.z, 0.0f); + } + else + { + Vector3f p = viewMat.MultiplyPoint3( (const Vector3f&)data.position ); + position.Set(p.x, p.y, p.z, 1.0f); + } + + m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Diffuse + light), data.color); + if (data.spotAngle > 0.0f) + { + // spot attenuation formula taken from D3D9 fixed-function emulation + // see: VertexPipeD3D9.cpp + const float cosTheta = cosf(Deg2Rad(data.spotAngle)*0.25f); + const float cosPhi = cosf(Deg2Rad(data.spotAngle)*0.5f); + const float cosDiff = cosTheta - cosPhi; + m_BuiltinParamValues.GetWritableVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Atten + light)).Set(cosPhi, (cosDiff != 0.0f) ? 1.0f / cosDiff : 1.0f, data.quadAtten, data.range*data.range); + } + else + { + // non-spot light + m_BuiltinParamValues.GetWritableVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Atten + light)).Set(-1.0f, 1.0f, data.quadAtten, data.range*data.range); + } +} + +void GFX_GL_IMPL::SetAmbient( const float ambient[4] ) +{ + DBG_LOG_GLES30("SetAmbient()"); + STATE.ambient.set (ambient[0], ambient[1], ambient[2], ambient[3]); + m_BuiltinParamValues.SetVectorParam(kShaderVecLightModelAmbient, Vector4f(ambient)); +} + +void GFX_GL_IMPL::EnableFog (const GfxFogParams& fog) +{ + DBG_LOG_GLES30("EnableFog()"); + DebugAssertIf( fog.mode <= kFogDisabled ); + m_FogParams = fog; +} + +void GFX_GL_IMPL::DisableFog() +{ + DBG_LOG_GLES30("DisableFog()"); + + if( m_FogParams.mode != kFogDisabled ) + { + m_FogParams.mode = kFogDisabled; + m_FogParams.density = 0.0f; + } +} + +VBO* GFX_GL_IMPL::CreateVBO() +{ + VBO* vbo = new GLES3VBO(); + OnCreateVBO(vbo); + return vbo; +} + +void GFX_GL_IMPL::DeleteVBO( VBO* vbo ) +{ + OnDeleteVBO(vbo); + delete vbo; +} + +DynamicVBO& GFX_GL_IMPL::GetDynamicVBO() +{ + if( !STATE.m_DynamicVBO ) { + STATE.m_DynamicVBO = new DynamicGLES3VBO(); + } + return *STATE.m_DynamicVBO; +} + +// ---------- render textures + +static FramebufferObjectManagerGLES30& GetFBOManager (DeviceStateGLES30& deviceState) +{ + if (!deviceState.m_fboManager) + deviceState.m_fboManager = new FramebufferObjectManagerGLES30(); + return *deviceState.m_fboManager; +} + +static RenderSurfaceGLES30* CreateRenderTexture (TextureDimension dim, TextureID texID, UInt32 internalFormat, int width, int height, int depth) +{ + if (dim == kTexDim2D) + { + Assert(depth == 1); + return new RenderTexture2DGLES30(texID, internalFormat, width, height); + } + else if (dim == kTexDimCUBE) + { + Assert(width == height && depth == 1); + return new RenderTextureCubeGLES30(texID, internalFormat, width, height); + } + else + { + Assert(!"Not supported"); + return 0; + } +} + +static RenderSurfaceGLES30* CreateShadowMapRenderTexture (TextureDimension dim, TextureID texID, UInt32 internalFormat, int width, int height, int depth) +{ + // \note Assumes that constructor binds texID! + if (dim == kTexDim2D) + { + Assert(depth == 1); + RenderTexture2DGLES30* tex = new RenderTexture2DGLES30(texID, internalFormat, width, height); + GLES_CHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE)); + GLES_CHK(glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL)); + return tex; + } + else if (dim == kTexDimCUBE) + { + Assert(width == height && depth == 1); + RenderTextureCubeGLES30* tex = new RenderTextureCubeGLES30(texID, internalFormat, width, height); + GLES_CHK(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE)); + GLES_CHK(glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL)); + return tex; + } + else + { + Assert(!"Not supported"); + return 0; + } +} + +static RenderSurfaceGLES30* CreateRenderBuffer (TextureDimension dim, UInt32 internalFormat, int width, int height, int depth, int numSamples) +{ + if (dim == kTexDim2D) + { + Assert(depth == 1); + return new RenderBufferGLES30(internalFormat, width, height, numSamples); + } + else if (dim == kTexDimCUBE) + { + Assert(width == height && depth == 1); + return new RenderBufferCubeGLES30(internalFormat, width, height, numSamples); + } + else + { + Assert(!"Not supported"); + return 0; + } +} + +RenderSurfaceHandle GFX_GL_IMPL::CreateRenderColorSurface (TextureID textureID, int width, int height, int samples, int depth, TextureDimension dim, RenderTextureFormat format, UInt32 createFlags) +{ + DBG_LOG_GLES30("CreateRenderColorSurface(id = %d, %dx%dx%d, samples = %d, dim = %d, fmt = %d, flags = 0x%04x)", textureID.m_ID, width, height, depth, samples, dim, format, createFlags); + + // \note Sample count 0 and 1 both map to non-multisampled textures. + + if (createFlags & kSurfaceCreateNeverUsed) + { + // Use dummy surface that is not backed by any real GL object. + return RenderSurfaceHandle(new DummyRenderSurfaceGLES30(width, height)); + } + else + { + const bool isSRGB = (createFlags & kSurfaceCreateSRGB) != 0; + const UInt32 internalFormat = isSRGB ? GL_SRGB8_ALPHA8 : GetColorFormatGLES30(format); + const bool useRBO = textureID.m_ID == 0 || samples > 1; + + Assert(internalFormat != GL_NONE); + Assert((createFlags & kSurfaceCreateShadowmap) == 0); + + if (useRBO) + { + // \todo [2013-06-04 pyry] There is no global graphics caps for max samples. + const int numSamplesToUse = std::min(gGraphicsCaps.gles30.maxSamples, std::max(samples,1)); + return RenderSurfaceHandle(CreateRenderBuffer(dim, internalFormat, width, height, depth, numSamplesToUse)); + } + else + return RenderSurfaceHandle(CreateRenderTexture(dim, textureID, internalFormat, width, height, depth)); + } + + return RenderSurfaceHandle(0); +} + +RenderSurfaceHandle GFX_GL_IMPL::CreateRenderDepthSurface (TextureID textureID, int width, int height, int samples, TextureDimension dim, DepthBufferFormat depthFormat, UInt32 createFlags) +{ + DBG_LOG_GLES30("CreateRenderDepthSurface(id = %d, %dx%d, samples = %d, dim = %d, fmt = %d, createFlags = 0x%04x)", textureID.m_ID, width, height, samples, dim, depthFormat, createFlags); + + // \note Sample count 0 and 1 both map to non-multisampled textures. + + if (depthFormat == kDepthFormatNone || (createFlags & kSurfaceCreateNeverUsed) != 0) + { + // Umm... Assuming that we don't want depth buffer at all, but still this is called? + return RenderSurfaceHandle(new DummyRenderSurfaceGLES30(width, height)); + } + else + { + const bool shadowMap = (createFlags & kSurfaceCreateShadowmap) != 0; + const bool useStencil = !shadowMap; + const UInt32 internalFormat = useStencil ? GetDepthStencilFormatGLES30(depthFormat) : GetDepthOnlyFormatGLES30(depthFormat); + const bool useRBO = textureID.m_ID == 0 || samples > 1; + + Assert(internalFormat != GL_NONE); + Assert(!shadowMap || !useRBO); + + if (useRBO) + { + // \todo [2013-06-04 pyry] There is no global graphics caps for max samples. + const int numSamplesToUse = std::min(gGraphicsCaps.gles30.maxSamples, std::max(samples,1)); + return RenderSurfaceHandle(CreateRenderBuffer(dim, internalFormat, width, height, 1, numSamplesToUse)); + } + else if (shadowMap) + return RenderSurfaceHandle(CreateShadowMapRenderTexture(dim, textureID, internalFormat, width, height, 1)); + else + return RenderSurfaceHandle(CreateRenderTexture(dim, textureID, internalFormat, width, height, 1)); + } + + return RenderSurfaceHandle(0); +} + +void GFX_GL_IMPL::DestroyRenderSurface (RenderSurfaceHandle& rs) +{ + DBG_LOG_GLES30("DestroyRenderSurface(%p)", rs.object); + + if (!rs.IsValid()) + return; + + RenderSurfaceGLES30* renderSurface = static_cast<RenderSurfaceGLES30*>(rs.object); + + // Default FBO should not be managed from outside. + Assert(!STATE.m_defaultFbo || !IsInFramebufferAttachmentsGLES30(*STATE.m_defaultFbo->GetAttachments(), renderSurface)); + + // If rs was attached to current FBO, unbind it. + if (STATE.m_activeFbo && IsInFramebufferAttachmentsGLES30(*STATE.m_activeFbo->GetAttachments(), renderSurface)) + { + if (STATE.m_defaultFbo) + BindFramebufferObjectGLES30(STATE.m_defaultFbo); + else + BindDefaultFramebufferGLES30(); + + STATE.m_activeFbo = STATE.m_defaultFbo; + } + + // Delete FBOs where renderSurface was attached. + STATE.m_fboManager->InvalidateSurface(renderSurface); + + delete renderSurface; + rs.object = 0; +} + +static bool IsAnyRSHandleValid (const RenderSurfaceHandle* handles, int numHandles) +{ + for (int ndx = 0; ndx < numHandles; ndx++) + { + if (handles[ndx].IsValid()) + return true; + } + return false; +} + +void GFX_GL_IMPL::SetRenderTargets (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face) +{ + bool hasColor = !colorHandles[0].object->backBuffer; + bool hasDepth = !depthHandle.object->backBuffer; + + DBG_LOG_GLES30("SetRenderTargets(count = %d, color = %s, depth = %s, mip = %d, face = %d)", count, (hasColor ? "yes" : "no"), (hasDepth ? "yes" : "no"), mipLevel, face); + + // \todo [2013-05-06 pyry] Enable SetRenderTargets() variant with flags and check if we should discard buffers. + // \todo [2013-05-02 pyry] It probably makes sense to do RT change deferred. + + Assert(count <= FramebufferAttachmentsGLES30::kMaxColorAttachments); + + Assert(colorHandles[0].IsValid() && depthHandle.IsValid()); + Assert(colorHandles[0].object->backBuffer == depthHandle.object->backBuffer); + + if(!hasColor && !hasDepth) + { + // Assuming default FB - right? + if (STATE.m_activeFbo != STATE.m_defaultFbo) + { + if (STATE.m_defaultFbo) + BindFramebufferObjectGLES30(STATE.m_defaultFbo); + else + BindDefaultFramebufferGLES30(); + + STATE.m_activeFbo = STATE.m_defaultFbo; + GetRealGfxDevice().GetFrameStats().AddRenderTextureChange(); + } + } + else + { + // Translate to FramebufferAttachments + FramebufferAttachmentsGLES30 attachments; + + attachments.numColorAttachments = count; + attachments.depthStencil = static_cast<RenderSurfaceGLES30*>(depthHandle.object); + attachments.cubemapFace = face; + + for (int ndx = 0; ndx < count; ndx++) + attachments.color[ndx] = static_cast<RenderSurfaceGLES30*>(colorHandles[ndx].object); + + // Create (or fetch from cache) FBO + FramebufferObjectGLES30* fbo = GetFBOManager(STATE).GetFramebufferObject(attachments); + + if (STATE.m_activeFbo != fbo) + { + BindFramebufferObjectGLES30(fbo); + STATE.m_activeFbo = fbo; + GetRealGfxDevice().GetFrameStats().AddRenderTextureChange(); + } + } +} + +void GFX_GL_IMPL::ResolveColorSurface (RenderSurfaceHandle srcHandle, RenderSurfaceHandle dstHandle) +{ + DBG_LOG_GLES30("ResolveColorSurface(src = %p, dst = %p)", srcHandle.object, dstHandle.object); + + // Fetch temporary FBOs for resolve - use single color attachment. + FramebufferObjectGLES30* srcFbo = 0; + FramebufferObjectGLES30* dstFbo = 0; + + Assert(srcHandle.object && dstHandle.object); + + for (int ndx = 0; ndx < 2; ndx++) + { + FramebufferAttachmentsGLES30 attachments; + attachments.numColorAttachments = 1; + attachments.color[0] = static_cast<RenderSurfaceGLES30*>(ndx ? srcHandle.object : dstHandle.object); + + (ndx ? srcFbo : dstFbo) = GetFBOManager(STATE).GetFramebufferObject(attachments); + } + + Assert(srcFbo && dstFbo); + + int width = static_cast<RenderSurfaceGLES30*>(dstHandle.object)->GetWidth(); + int height = static_cast<RenderSurfaceGLES30*>(dstHandle.object)->GetHeight(); + + glBindFramebuffer(GL_READ_FRAMEBUFFER, srcFbo->GetFboID()); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dstFbo->GetFboID()); + GLES_CHK(glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST)); + + // Restore old FBO binding + GLES_CHK(glBindFramebuffer(GL_FRAMEBUFFER, STATE.m_activeFbo ? STATE.m_activeFbo->GetFboID() : 0)); +} + +RenderSurfaceHandle GFX_GL_IMPL::GetActiveRenderColorSurface(int index) +{ + Assert(0 <= index && index <= FramebufferAttachmentsGLES30::kMaxColorAttachments); + + if (STATE.m_activeFbo) + return RenderSurfaceHandle(STATE.m_activeFbo->GetColorAttachment(index)); + else + return RenderSurfaceHandle(0); +} + +RenderSurfaceHandle GFX_GL_IMPL::GetActiveRenderDepthSurface() +{ + if (STATE.m_activeFbo) + return RenderSurfaceHandle(STATE.m_activeFbo->GetDepthStencilAttachment()); + else + return RenderSurfaceHandle(0); +} + +void GFX_GL_IMPL::SetSurfaceFlags (RenderSurfaceHandle surf, UInt32 flags, UInt32 keepFlags) +{ + // \todo [2013-04-29 pyry] Implement handling for flags! +} + +void GFX_GL_IMPL::DiscardContents (RenderSurfaceHandle& rs) +{ + DBG_LOG_GLES30("DiscardContents(%p)", rs.object); + + if (!rs.IsValid()) + return; // \todo [2013-06-05 pyry] Bug in threaded device code causes DiscardContents() calls to invalid handles. + + FramebufferObjectGLES30* curFbo = STATE.m_activeFbo; + GLenum discardAttachments[FramebufferAttachmentsGLES30::kMaxColorAttachments+1]; + int attachNdx = 0; + + if (curFbo) + { + // Check if rs is attached to current fbo. + for (int colorNdx = 0; colorNdx < curFbo->GetNumColorAttachments(); colorNdx++) + { + if (rs.object == curFbo->GetColorAttachment(colorNdx)) + discardAttachments[attachNdx++] = GL_COLOR_ATTACHMENT0+colorNdx; + } + + if (rs.object == curFbo->GetDepthStencilAttachment()) + { + // \todo [2013-05-02 pyry] Should we check if FBO actually has stencil attachment enabled? + discardAttachments[attachNdx++] = GL_DEPTH_STENCIL_ATTACHMENT; + } + } + + Assert(attachNdx <= (int)(sizeof(discardAttachments)/sizeof(discardAttachments[0]))); + if (attachNdx > 0) + GLES_CHK(glInvalidateFramebuffer(GL_FRAMEBUFFER, attachNdx, &discardAttachments[attachNdx])); + + DBG_LOG_GLES30(" .. discarded in current FBO = %s", (attachNdx > 0) ? "true" : "false"); + + // If attachment was not discarded yet, do it later when it is bound. + if (attachNdx == 0) + { + RenderSurfaceGLES30* renderSurface = static_cast<RenderSurfaceGLES30*>(rs.object); + renderSurface->SetFlags(renderSurface->GetFlags() | RenderSurfaceGLES30::kDiscardOnBind); + } +} + +// ---------- uploading textures + +void GFX_GL_IMPL::UploadTexture2D( TextureID texture, TextureDimension dimension, UInt8* srcData, int srcSize, int width, int height, TextureFormat format, int mipCount, UInt32 uploadFlags, int skipMipLevels, TextureUsageMode usageMode, TextureColorSpace colorSpace ) +{ + ::UploadTexture2DGLES3( texture, dimension, srcData, width, height, format, mipCount, uploadFlags, skipMipLevels, colorSpace ); +} + +void GFX_GL_IMPL::UploadTextureSubData2D( TextureID texture, UInt8* srcData, int srcSize, int mipLevel, int x, int y, int width, int height, TextureFormat format, TextureColorSpace colorSpace ) +{ + ::UploadTextureSubData2DGLES3( texture, srcData, mipLevel, x, y, width, height, format, colorSpace ); +} + +void GFX_GL_IMPL::UploadTextureCube( TextureID texture, UInt8* srcData, int srcSize, int faceDataSize, int size, TextureFormat format, int mipCount, UInt32 uploadFlags, TextureColorSpace colorSpace ) +{ + ::UploadTextureCubeGLES3( texture, srcData, faceDataSize, size, format, mipCount, uploadFlags, colorSpace ); +} + +void GFX_GL_IMPL::UploadTexture3D( TextureID texture, UInt8* srcData, int srcSize, int width, int height, int depth, TextureFormat format, int mipCount, UInt32 uploadFlags ) +{ + // \todo [2013-04-16 pyry] Add support. + ErrorString("3D textures are not supported by OpenGLES!"); +} + +void GFX_GL_IMPL::DeleteTexture(TextureID texture) +{ + GLuint targetTex = (GLuint)TextureIdMap::QueryNativeTexture(texture); + if(targetTex == 0) + return; + + REGISTER_EXTERNAL_GFX_DEALLOCATION(texture.m_ID); + GLES_CHK(glDeleteTextures(1, &targetTex)); + + // invalidate texture unit states that used this texture + for( int i = 0; i < gGraphicsCaps.maxTexUnits; ++i ) + { + TextureUnitStateGLES3& currTex = STATE.textures[i]; + if( currTex.texID == targetTex ) + currTex.Invalidate(); + } + + TextureIdMap::RemoveTexture(texture); +} + +// ---------- context + +GfxDevice::PresentMode GFX_GL_IMPL::GetPresentMode() +{ + return UNITY_IPHONE ? kPresentAfterDraw : kPresentBeforeUpdate; +} + +static void ResetFboBindingToDefault (DeviceStateGLES30& state) +{ + if (state.m_activeFbo != state.m_defaultFbo) + { + if (state.m_defaultFbo) + BindFramebufferObjectGLES30(state.m_defaultFbo); + else + BindDefaultFramebufferGLES30(); + state.m_activeFbo = state.m_defaultFbo; + } +} + +void GFX_GL_IMPL::BeginFrame() +{ + DBG_LOG_GLES30("BeginFrame()"); + m_InsideFrame = true; + + if (gGraphicsCaps.hasTiledGPU) + { + // \todo [2013-05-02 pyry] Should we reset FBO binding here? + ResetFboBindingToDefault(STATE); + if(STATE.scissor) + GLES_CHK(glDisable(GL_SCISSOR_TEST)); + GLES_CHK(glViewport(0, 0, 65536, 65536)); + GLES_CHK(glClearColor(0.0f, 0.0f, 0.0f, 1.0f)); + GLES_CHK(glClearStencil(0)); + GLES_CHK(glClearDepthf(1.0f)); + GLES_CHK(glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_STENCIL_BUFFER_BIT)); + GLES_CHK(glViewport(STATE.viewport[0], STATE.viewport[1], STATE.viewport[2], STATE.viewport[3])); + if(STATE.scissor) + GLES_CHK(glEnable(GL_SCISSOR_TEST)); + + } +} +void GFX_GL_IMPL::EndFrame() +{ + // \todo [2013-05-02 pyry] Do we really want to reset FBO binding here? + ResetFboBindingToDefault(STATE); + if (STATE.m_activeFbo != 0) + { + // If rendering to FBO, discard contents. + static const GLenum attachments[] = { GL_COLOR_ATTACHMENT0, GL_DEPTH_STENCIL_ATTACHMENT }; + GLES_CHK(glInvalidateFramebuffer(GL_FRAMEBUFFER, sizeof(attachments)/sizeof(attachments[0]), &attachments[0])); + } + else + { + // System "FBO", discard only depthstencil + static const GLenum attachments[] = { GL_DEPTH, GL_STENCIL }; + GLES_CHK(glInvalidateFramebuffer(GL_FRAMEBUFFER, sizeof(attachments)/sizeof(attachments[0]), &attachments[0])); + } + + GetBufferManagerGLES30()->AdvanceFrame(); + + DBG_LOG_GLES30("EndFrame()"); + m_InsideFrame = false; +} + +bool GFX_GL_IMPL::IsValidState() +{ +#if UNITY_ANDROID + return ContextGLES::IsValid(); +#else + return true; +#endif +} + +bool GFX_GL_IMPL::HandleInvalidState() +{ +#if UNITY_ANDROID + bool needReload; + if (!ContextGLES::HandleInvalidState(&needReload)) + return false; + if (needReload) + ReloadResources(); + return true; +#else + return true; +#endif +} + +void GFX_GL_IMPL::PresentFrame() +{ + DBG_LOG_GLES30("===================================="); + DBG_LOG_GLES30("===================================="); + DBG_LOG_GLES30("PresentFrame"); + DBG_LOG_GLES30("===================================="); + DBG_LOG_GLES30("===================================="); + +#if UNITY_WIN + PresentContextGLES30(); +#else + PresentContextGLES(); +#endif +} + +void GFX_GL_IMPL::FinishRendering() +{ + GLES_CHK(glFinish()); +} + +// ---------- immediate mode rendering + +// we break very large immediate mode submissions into multiple batches internally +const int kMaxImmediateVerticesPerDraw = 2048; + + +ImmediateModeGLES30::ImmediateModeGLES30() + : m_Mode (kPrimitiveTriangles) + , m_IndexBufferQuads(0) +{ +#if 0 + m_QuadsIB = (UInt16*)UNITY_MALLOC(kMemGeometry, kMaxImmediateVerticesPerDraw*6*sizeof(UInt16)); + UInt32 baseIndex = 0; + UInt16* ibPtr = m_QuadsIB; + for( int i = 0; i < kMaxImmediateVerticesPerDraw; ++i ) + { + ibPtr[0] = baseIndex + 1; + ibPtr[1] = baseIndex + 2; + ibPtr[2] = baseIndex; + ibPtr[3] = baseIndex + 2; + ibPtr[4] = baseIndex + 3; + ibPtr[5] = baseIndex; + baseIndex += 4; + ibPtr += 6; + } +#endif +} + +ImmediateModeGLES30::~ImmediateModeGLES30() +{ + Invalidate(); +} + +void ImmediateModeGLES30::Invalidate() +{ + if (m_IndexBufferQuads) + { + m_IndexBufferQuads->Release(); + m_IndexBufferQuads = 0; + } + + m_Vertices.clear(); + memset(&m_Current, 0, sizeof(m_Current)); +} + +void GFX_GL_IMPL::ImmediateVertex( float x, float y, float z ) +{ + // If the current batch is becoming too large, internally end it and begin it again. + size_t currentSize = STATE.m_Imm.m_Vertices.size(); + if( currentSize >= kMaxImmediateVerticesPerDraw - 4 ) + { + GfxPrimitiveType mode = STATE.m_Imm.m_Mode; + // For triangles, break batch when multiple of 3's is reached. + if( mode == kPrimitiveTriangles && currentSize % 3 == 0 ) + { + ImmediateEnd(); + ImmediateBegin( mode ); + } + // For other primitives, break on multiple of 4's. + // NOTE: This won't quite work for triangle strips, but we'll just pretend + // that will never happen. + else if( mode != kPrimitiveTriangles && currentSize % 4 == 0 ) + { + ImmediateEnd(); + ImmediateBegin( mode ); + } + } + Vector3f& vert = STATE.m_Imm.m_Current.vertex; + vert.x = x; + vert.y = y; + vert.z = z; + STATE.m_Imm.m_Vertices.push_back( STATE.m_Imm.m_Current ); +} + +void GFX_GL_IMPL::ImmediateNormal( float x, float y, float z ) +{ + STATE.m_Imm.m_Current.normal.x = x; + STATE.m_Imm.m_Current.normal.y = y; + STATE.m_Imm.m_Current.normal.z = z; +} + +void GFX_GL_IMPL::ImmediateColor( float r, float g, float b, float a ) +{ + r = clamp01(r); + g = clamp01(g); + b = clamp01(b); + a = clamp01(a); + + STATE.m_Imm.m_Current.color = + ((UInt32)(a * 255.0f) << 24) | + ((UInt32)(b * 255.0f) << 16) | + ((UInt32)(g * 255.0f) << 8) | + ((UInt32)(r * 255.0f)); +} + +void GFX_GL_IMPL::ImmediateTexCoordAll( float x, float y, float z ) +{ + for( int i = 0; i < gGraphicsCaps.maxTexCoords; ++i ) + { + Vector3f& uv = STATE.m_Imm.m_Current.texCoords[i]; + uv.x = x; + uv.y = y; + uv.z = z; + } +} + +void GFX_GL_IMPL::ImmediateTexCoord( int unit, float x, float y, float z ) +{ + if( unit < 0 || unit >= 8 ) + { + ErrorString( "Invalid unit for texcoord" ); + return; + } + Vector3f& uv = STATE.m_Imm.m_Current.texCoords[unit]; + uv.x = x; + uv.y = y; + uv.z = z; +} + +void GFX_GL_IMPL::ImmediateBegin( GfxPrimitiveType type ) +{ + STATE.m_Imm.m_Mode = type; + STATE.m_Imm.m_Vertices.clear(); +} + +void GFX_GL_IMPL::ImmediateEnd() +{ + if (STATE.m_Imm.m_Vertices.empty()) + return; + + const UInt32 minBufferThreshold = 2048; + + const int numVertices = STATE.m_Imm.m_Vertices.size(); + const UInt32 vertexBufStride = (UInt32)sizeof(ImmediateVertexGLES30); + const UInt32 vertexBufUsage = GL_STREAM_DRAW; + const UInt32 vertexBufSize = vertexBufStride*numVertices; + const bool useBuffer = vertexBufSize >= minBufferThreshold; + DataBufferGLES30* vertexBuffer = useBuffer ? GetBufferManagerGLES30()->AcquireBuffer(numVertices*vertexBufStride, vertexBufUsage) : 0; + VertexArrayInfoGLES30 vertexSetup; + + // \todo [2013-05-31 pyry] Recreate or update? + if (vertexBuffer) + vertexBuffer->RecreateWithData(vertexBufSize, vertexBufUsage, &STATE.m_Imm.m_Vertices[0]); + + if (STATE.m_Imm.m_Mode == kPrimitiveQuads && !STATE.m_Imm.m_IndexBufferQuads) + { + // \todo [2013-05-31 pyry] Move somewhere else. + const int quadCount = kMaxImmediateVerticesPerDraw/4; + const int quadIndexCount = quadCount * 6; + const int indexBufferSize = quadIndexCount * sizeof(UInt16); + const UInt32 indexBufferUsage = GL_STATIC_DRAW; + std::vector<UInt16> quadIndices (quadIndexCount); + + for (int quadNdx = 0; quadNdx < quadCount; ++quadNdx) + { + const UInt16 srcBaseNdx = quadNdx*4; + const int dstBaseNdx = quadNdx*6; + quadIndices[dstBaseNdx + 0] = srcBaseNdx + 1; + quadIndices[dstBaseNdx + 1] = srcBaseNdx + 2; + quadIndices[dstBaseNdx + 2] = srcBaseNdx; + quadIndices[dstBaseNdx + 3] = srcBaseNdx + 2; + quadIndices[dstBaseNdx + 4] = srcBaseNdx + 3; + quadIndices[dstBaseNdx + 5] = srcBaseNdx; + } + + STATE.m_Imm.m_IndexBufferQuads = GetBufferManagerGLES30()->AcquireBuffer(indexBufferSize, indexBufferUsage); + STATE.m_Imm.m_IndexBufferQuads->RecreateWithData(indexBufferSize, indexBufferUsage, &quadIndices[0]); + } + + // Fill in vertex setup info. + { + const UInt8* basePtr = vertexBuffer ? 0 : (const UInt8*)&STATE.m_Imm.m_Vertices[0]; + const UInt32 buffer = vertexBuffer ? vertexBuffer->GetBuffer() : 0; + + // \todo [2013-05-31 pyry] Do not send unused attributes! + vertexSetup.enabledArrays = (1<<kGLES3AttribLocationPosition) + | (1<<kGLES3AttribLocationColor) + | (1<<kGLES3AttribLocationNormal); + + // All are sourcing from same buffer + for (int i = 0; i < kGLES3MaxVertexAttribs; i++) + vertexSetup.buffers[i] = buffer; + + vertexSetup.arrays[kGLES3AttribLocationPosition] = VertexInputInfoGLES30(basePtr + 0, kChannelFormatFloat, 3, vertexBufStride); + vertexSetup.arrays[kGLES3AttribLocationNormal] = VertexInputInfoGLES30(basePtr + 3*sizeof(float), kChannelFormatFloat, 3, vertexBufStride); + vertexSetup.arrays[kGLES3AttribLocationColor] = VertexInputInfoGLES30(basePtr + 6*sizeof(float), kChannelFormatColor, 4, vertexBufStride); + UInt32 curOffset = 6*sizeof(float) + sizeof(UInt32); + + for (int texCoordNdx = 0; texCoordNdx < (kGLES3MaxVertexAttribs-kGLES3AttribLocationTexCoord0); texCoordNdx++) + { + const int attribLoc = kGLES3AttribLocationTexCoord0+texCoordNdx; + + if (attribLoc < gGraphicsCaps.gles30.maxAttributes) + { + vertexSetup.enabledArrays |= (1<<attribLoc); + vertexSetup.arrays[kGLES3AttribLocationTexCoord0+texCoordNdx] = + VertexInputInfoGLES30(basePtr + curOffset, kChannelFormatFloat, 3, vertexBufStride); + curOffset += 3*sizeof(float); + } + } + } + + // Setup state + BeforeDrawCall(true /* immediate */); + SetupDefaultVertexArrayStateGLES30(vertexSetup); + + switch (STATE.m_Imm.m_Mode) + { + case kPrimitiveTriangles: + GLES_CHK(glDrawArrays(GL_TRIANGLES, 0, numVertices)); + m_Stats.AddDrawCall(numVertices / 3, numVertices); + break; + + case kPrimitiveTriangleStripDeprecated: + GLES_CHK(glDrawArrays(GL_TRIANGLE_STRIP, 0, numVertices)); + m_Stats.AddDrawCall(numVertices - 2, numVertices); + break; + + case kPrimitiveLines: + GLES_CHK(glDrawArrays(GL_LINES, 0, numVertices)); + m_Stats.AddDrawCall(numVertices / 2, numVertices); + break; + + case kPrimitiveQuads: + Assert(STATE.m_Imm.m_IndexBufferQuads); + GLES_CHK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, STATE.m_Imm.m_IndexBufferQuads->GetBuffer())); + GLES_CHK(glDrawElements(GL_TRIANGLES, (numVertices/4)*6, GL_UNSIGNED_SHORT, 0)); + GLES_CHK(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0)); + m_Stats.AddDrawCall(numVertices / 2, numVertices); + break; + + default: + AssertString("ImmediateEnd: unknown draw mode"); + } + + if (vertexBuffer) + vertexBuffer->Release(); +} + +// ---------- readback path + +static int GetFirstValidColorAttachmentNdx (const FramebufferObjectGLES30* fbo) +{ + for (int colorNdx = 0; colorNdx < fbo->GetNumColorAttachments(); colorNdx++) + { + if (fbo->GetColorAttachment(colorNdx)) + return colorNdx; + } + + return -1; +} + +static bool IsRenderSurfaceFormatCompatibleWithRGBA8Read (UInt32 format) +{ + switch (format) + { + case GL_RGBA8: + case GL_RGB8: + case GL_RG8: + case GL_R8: + case GL_RGB565: + case GL_RGB10_A2: + case GL_RGBA4: + case GL_RGB5_A1: + case GL_SRGB8_ALPHA8: + case GL_SRGB8: + return true; + + default: + return false; + } +} + +static bool CanReadRGBA8FromFirstColorAttachment (const FramebufferObjectGLES30* fbo) +{ + int ndx = GetFirstValidColorAttachmentNdx(fbo); + if (ndx >= 0) + return IsRenderSurfaceFormatCompatibleWithRGBA8Read(fbo->GetColorAttachment(ndx)->GetFormat()); + else + return false; +} + +static void ReadPixelsFromDefaultFramebufferRGBA8 (int x, int y, int width, int height, UInt8* dstPtr) +{ + GLES_CHK(glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, dstPtr)); +} + +static void ReadPixelsFromActiveFramebufferObjectRGBA8 (DeviceStateGLES30& state, int x, int y, int width, int height, UInt8* dstPtr) +{ + Assert(state.m_activeFbo != 0); + Assert(CanReadRGBA8FromFirstColorAttachment(state.m_activeFbo)); + + FramebufferObjectGLES30* activeFbo = state.m_activeFbo; + const int colorNdx = GetFirstValidColorAttachmentNdx(state.m_activeFbo); + const RenderSurfaceGLES30* colorSurface = activeFbo->GetColorAttachment(colorNdx); + const bool requiresResolve = colorSurface->GetNumSamples() > 1; + + if (requiresResolve) + { + FramebufferObjectManagerGLES30& fboManager = GetFBOManager(state); + FramebufferObjectGLES30* resolveBuffer = GetResolveFramebufferObjectGLES30(&fboManager, colorSurface->GetFormat(), 0, + colorSurface->GetWidth(), colorSurface->GetHeight()); + + GLenum drawBuffer = GL_COLOR_ATTACHMENT0; + GLES_CHK(glDrawBuffers(1, &drawBuffer)); + GLES_CHK(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, resolveBuffer->GetFboID())); + + // \note active FBO is already GL_READ_FRAMEBUFFER + GLES_CHK(glReadBuffer(GL_COLOR_ATTACHMENT0+colorNdx)); + + // Resolve blit. + GLES_CHK(glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST)); + + // Read from resolve buffer. + GLES_CHK(glReadBuffer(GL_COLOR_ATTACHMENT0)); + GLES_CHK(glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, dstPtr)); + + // Restore binding. + BindFramebufferObjectGLES30(activeFbo); + } + else + { + GLES_CHK(glReadBuffer(GL_COLOR_ATTACHMENT0+colorNdx)); + GLES_CHK(glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, dstPtr)); + } +} + +void GFX_GL_IMPL::ResolveDepthIntoTexture (RenderSurfaceHandle colorHandle, RenderSurfaceHandle depthHandle) +{ + FramebufferAttachmentsGLES30 att; + att.numColorAttachments = 1; + att.color[0] = static_cast<RenderSurfaceGLES30 *>(colorHandle.object); + att.depthStencil = static_cast<RenderSurfaceGLES30 *>(depthHandle.object); + att.cubemapFace = kCubeFaceUnknown; + + FramebufferObjectGLES30 *helperFBO = GetFBOManager(STATE).GetFramebufferObject(att); + FramebufferObjectGLES30 *oldFBO = STATE.m_activeFbo; + + + // use the full size of the depth buffer, sub-rects are not needed and might not work on some hardware + GLint x = 0; + GLint y = 0; + GLint width = att.depthStencil->GetWidth(); + GLint height = att.depthStencil->GetHeight(); + + // bind helper FBO + GLES_CHK(glBindFramebuffer(GL_FRAMEBUFFER, helperFBO->GetFboID())); + + GLES_CHK(glReadBuffer (GL_NONE)); + + // blit + GLES_CHK(glBindFramebuffer (GL_READ_FRAMEBUFFER, oldFBO->GetFboID())); + GLES_CHK(glBindFramebuffer (GL_DRAW_FRAMEBUFFER, helperFBO->GetFboID())); + GLES_CHK(glBlitFramebuffer (x, y, x + width, y + height, x, y, x + width, y + height, GL_DEPTH_BUFFER_BIT, GL_NEAREST)); + + // restore the previously bound FBO + GLES_CHK(glBindFramebuffer (GL_FRAMEBUFFER, oldFBO->GetFboID())); + + +} + + +bool GFX_GL_IMPL::CaptureScreenshot (int left, int bottom, int width, int height, UInt8* rgba32) +{ + if (STATE.m_activeFbo) + { + if (CanReadRGBA8FromFirstColorAttachment(STATE.m_activeFbo)) + { + ReadPixelsFromActiveFramebufferObjectRGBA8(STATE, left, bottom, width, height, rgba32); + return true; + } + else + { + ErrorString("Active FBO is not compatible with screenshots"); + return false; + } + } + else + { + ReadPixelsFromDefaultFramebufferRGBA8(left, bottom, width, height, rgba32); + return true; + } +} + +bool GFX_GL_IMPL::ReadbackImage (ImageReference& image, int left, int bottom, int width, int height, int destX, int destY) +{ + const bool coordsOk = destX == 0; + const bool formatOk = image.GetFormat() == kTexFormatRGBA32; + const bool strideOk = image.GetRowBytes() == 4*width; + const bool directRead = coordsOk && formatOk && strideOk; + + if (directRead) + return CaptureScreenshot(left, bottom, width, height, image.GetRowPtr(destY)); + else + { + std::vector<UInt8> tmpBuf(width*height*4); + if (!CaptureScreenshot(left, bottom, width, height, &tmpBuf[0])) + return false; + + ImageReference blitSrc(width, height, 4*width, kTexFormatRGBA32, &tmpBuf[0]); + image.BlitImage(destX, destY, blitSrc); + + return true; + } +} + +void GFX_GL_IMPL::GrabIntoRenderTexture( RenderSurfaceHandle rs, RenderSurfaceHandle rd, int x, int y, int width, int height ) +{ + if (!rs.IsValid()) + return; + + RenderSurfaceGLES30* dstColorSurface = static_cast<RenderSurfaceGLES30*>(rs.object); + RenderSurfaceGLES30* dstDepthSurface = static_cast<RenderSurfaceGLES30*>(rd.object); + + // Grabbing to MSAA targets is not supported. + if (dstColorSurface->GetNumSamples() > 1 || (dstDepthSurface && dstDepthSurface->GetNumSamples() > 1)) + { + ErrorString("GrabIntoRenderTexture(): Grabbing to MSAA RenderSurfaces is not supported"); + return; + } + + if (dstColorSurface->GetType() == RenderSurfaceGLES30::kTypeTexture2D && !dstDepthSurface && !STATE.m_activeFbo) + { + // Simple path: use glCopyTexSubImage() + RenderTexture2DGLES30* dstColorTex = static_cast<RenderTexture2DGLES30*>(dstColorSurface); + + GetRealGfxDevice().SetTexture(kShaderFragment, 0, 0, dstColorTex->GetTextureID(), kTexDim2D, std::numeric_limits<float>::infinity()); + GLES_CHK(glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, x, y, width, height)); + } + else + { + // Temporary dst fbo. + FramebufferObjectManagerGLES30& fboManager = GetFBOManager(STATE); + FramebufferObjectGLES30* dstFbo = 0; + { + FramebufferAttachmentsGLES30 attachments; + attachments.numColorAttachments = 1; + attachments.color[0] = dstColorSurface; + attachments.depthStencil = dstDepthSurface; + + dstFbo = fboManager.GetFramebufferObject(attachments); + } + + bool copyColor = false; + bool copyDepth = false; + bool colorNeedsResolve = false; + bool depthNeedsResolve = false; + UInt32 srcColorFormat = 0; + UInt32 srcDepthFormat = 0; + GLenum srcColorAttachment = 0; + + if (STATE.m_activeFbo) + { + const int srcColorNdx = GetFirstValidColorAttachmentNdx(STATE.m_activeFbo); + const RenderSurfaceGLES30* srcColorSurface = srcColorNdx >= 0 ? STATE.m_activeFbo->GetColorAttachment(srcColorNdx) : 0; + const RenderSurfaceGLES30* srcDepthSurface = STATE.m_activeFbo->GetDepthStencilAttachment() ? STATE.m_activeFbo->GetDepthStencilAttachment() : 0; + + copyColor = srcColorSurface && dstColorSurface; + copyDepth = dstColorSurface && dstDepthSurface; + colorNeedsResolve = copyColor && srcColorSurface->GetNumSamples() > 1; + depthNeedsResolve = copyDepth && srcDepthSurface->GetNumSamples() > 1; + srcColorFormat = srcColorSurface ? srcColorSurface->GetFormat() : 0; + srcDepthFormat = srcDepthSurface ? srcDepthSurface->GetFormat() : 0; + srcColorAttachment = GL_COLOR_ATTACHMENT0 + srcColorNdx; + } + else + { + const bool isMSAA = queryInt(GL_SAMPLE_BUFFERS) > 0; + + srcColorFormat = GetDefaultFramebufferColorFormatGLES30(); + srcDepthFormat = GetDefaultFramebufferDepthFormatGLES30(); + copyColor = srcColorFormat != 0 && dstColorSurface; + copyDepth = srcDepthFormat != 0 && dstDepthSurface; + colorNeedsResolve = isMSAA; + depthNeedsResolve = isMSAA; + srcColorAttachment = GL_BACK; + } + + const bool colorFormatMatch = !copyColor || srcColorFormat == dstColorSurface->GetFormat(); + const bool depthFormatMatch = !copyDepth || srcDepthFormat == dstDepthSurface->GetFormat(); + const bool copyBoundsOk = x == 0 && y == 0; + const bool copyDirectly = (!colorNeedsResolve || (colorFormatMatch && copyBoundsOk)) && (!depthNeedsResolve || (depthFormatMatch && copyBoundsOk)); + const UInt32 blitBuffers = (copyColor?GL_COLOR_BUFFER_BIT:0)|(copyDepth?GL_DEPTH_BUFFER_BIT:0); + + // \note There are blits that are not supported altogether. For example blitting + // from unorm to integer format. Supporting them would require emulating the + // blit and even in such case the semantics are rather vague. So we just rely + // on GL giving an error if user attempts to do something strange. + + if (copyDirectly) + { + GLenum drawBuffer = GL_COLOR_ATTACHMENT0; + + GLES_CHK(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dstFbo->GetFboID())); + GLES_CHK(glDrawBuffers(1, &drawBuffer)); + + // \note active FBO is already GL_READ_FRAMEBUFFER + GLES_CHK(glReadBuffer(srcColorAttachment)); + + GLES_CHK(glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, blitBuffers, GL_NEAREST)); + } + else + { + Assert(colorNeedsResolve || depthNeedsResolve); + + GLenum drawBuffer = GL_COLOR_ATTACHMENT0; + GLES_CHK(glDrawBuffers(1, &drawBuffer)); + + FramebufferObjectGLES30* resolveBuffer = GetResolveFramebufferObjectGLES30(&fboManager, + copyColor ? srcColorFormat : 0, + copyDepth ? srcDepthFormat : 0, + width, height); + + GLES_CHK(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, resolveBuffer->GetFboID())); + + // \note active FBO is already GL_READ_FRAMEBUFFER + GLES_CHK(glReadBuffer(srcColorAttachment)); + + // Resolve blit. + GLES_CHK(glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, blitBuffers, GL_NEAREST)); + + // Blit from resolve buffer to destination. + GLES_CHK(glBindFramebuffer(GL_READ_FRAMEBUFFER, resolveBuffer->GetFboID())); + GLES_CHK(glBindFramebuffer(GL_DRAW_FRAMEBUFFER, dstFbo->GetFboID())); + GLES_CHK(glReadBuffer(GL_COLOR_ATTACHMENT0)); + GLES_CHK(glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, blitBuffers, GL_NEAREST)); + } + + // Restore readbuffer state. + GLES_CHK(glReadBuffer(GL_BACK)); + + // Restore binding. + if (!STATE.m_activeFbo) + BindDefaultFramebufferGLES30(); + else + BindFramebufferObjectGLES30(STATE.m_activeFbo); + } +} + +#if ENABLE_PROFILER + +void GFX_GL_IMPL::BeginProfileEvent(const char* name) +{ + if(gGraphicsCaps.gles30.hasDebugMarkers) + gGles3ExtFunc.glPushGroupMarkerEXT(0, name); +} + +void GFX_GL_IMPL::EndProfileEvent() +{ + if(gGraphicsCaps.gles30.hasDebugMarkers) + gGles3ExtFunc.glPopGroupMarkerEXT(); +} + +GfxTimerQuery* GFX_GL_IMPL::CreateTimerQuery() +{ + if( gGraphicsCaps.hasTimerQuery ) + return new TimerQueryGLES30; + return NULL; +} + +void GFX_GL_IMPL::DeleteTimerQuery(GfxTimerQuery* query) +{ + delete query; +} + +void GFX_GL_IMPL::BeginTimerQueries() +{ + if( !gGraphicsCaps.hasTimerQuery ) + return; + + g_TimerQueriesGLES30.BeginTimerQueries(); +} + +void GFX_GL_IMPL::EndTimerQueries() +{ + if( !gGraphicsCaps.hasTimerQuery ) + return; + + g_TimerQueriesGLES30.EndTimerQueries(); +} + +#endif // ENABLE_PROFILER + +typedef std::map<FixedFunctionStateGLES30, FixedFunctionProgramGLES30*, FullStateCompareGLES30> FFProgramCacheT; +typedef std::map<FixedFunctionStateGLES30, GLShaderID, VertexStateCompareGLES30> FFVertexProgramCacheT; +typedef std::map<FixedFunctionStateGLES30, GLShaderID, FragmentStateCompareGLES30> FFFragmentProgramCacheT; + +static FFProgramCacheT g_FixedFunctionProgramCache; +static FFVertexProgramCacheT g_FFVertexProgramCache; +static FFFragmentProgramCacheT g_FFFragmentProgramCache; + +static void ClearFixedFunctionPrograms() +{ + for (FFVertexProgramCacheT::iterator it = g_FFVertexProgramCache.begin(); it != g_FFVertexProgramCache.end(); ++it) + { + GLES_CHK(glDeleteShader(it->second)); + } + g_FFVertexProgramCache.clear(); + for (FFFragmentProgramCacheT::iterator it = g_FFFragmentProgramCache.begin(); it != g_FFFragmentProgramCache.end(); ++it) + { + GLES_CHK(glDeleteShader(it->second)); + } + g_FFFragmentProgramCache.clear(); + + for(FFProgramCacheT::iterator i = g_FixedFunctionProgramCache.begin(); i != g_FixedFunctionProgramCache.end(); ++i) + { + delete i->second; + } + g_FixedFunctionProgramCache.clear(); + +} + +static const FixedFunctionProgramGLES30* GetFixedFunctionProgram(const FixedFunctionStateGLES30& state) +{ + FFProgramCacheT::const_iterator cachedProgIt = g_FixedFunctionProgramCache.find(state); + if (cachedProgIt != g_FixedFunctionProgramCache.end()) + return cachedProgIt->second; + + // Cache miss, create fixed function program + // NOTE: don't worry too much about performance of vertex/fragment maps + // shader building/compilation is crazy expensive anyway + FFVertexProgramCacheT::const_iterator vertexProgIt = g_FFVertexProgramCache.find(state); + FFFragmentProgramCacheT::const_iterator fragmentProgIt = g_FFFragmentProgramCache.find(state); + + GLShaderID vertexShader = (vertexProgIt != g_FFVertexProgramCache.end())? vertexProgIt->second: 0; + GLShaderID fragmentShader = (fragmentProgIt != g_FFFragmentProgramCache.end())? fragmentProgIt->second: 0; + + if (vertexShader == 0) + { + vertexShader = glCreateShader(GL_VERTEX_SHADER); + std::string src = BuildVertexShaderSourceGLES30(state); + const char* cStr = src.c_str(); + + DBG_SHADER_VERBOSE_GLES30("Compiling generated vertex shader"); + GlslGpuProgramGLES30::CompileGlslShader(vertexShader, cStr); + GLESAssert(); + + g_FFVertexProgramCache[state] = vertexShader; + } + + if (fragmentShader == 0) + { + fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); + std::string src = BuildFragmentShaderSourceGLES30(state); + const char* cStr = src.c_str(); + + DBG_SHADER_VERBOSE_GLES30("Compiling generated fragment shader"); + GlslGpuProgramGLES30::CompileGlslShader(fragmentShader, cStr); + GLESAssert(); + + g_FFFragmentProgramCache[state] = fragmentShader; + } + + DBG_SHADER_VERBOSE_GLES30("Creating and linking GLES program"); + FixedFunctionProgramGLES30* ffProg = new FixedFunctionProgramGLES30(vertexShader, fragmentShader); + g_FixedFunctionProgramCache[state] = ffProg; + + return ffProg; +} + +static bool ComputeTextureTransformMatrix(TextureUnitStateGLES3 const& tex, Matrix4x4f const& worldViewMatrix, Matrix4x4f const& worldMatrix, + Matrix4x4f& outMatrix) +{ + switch (tex.texGen) + { + case kTexGenDisabled: + // NOTE: although tex-gen can be disabled + // textureMatrix can contain UV scale/offset + // so we will set it + case kTexGenObject: + if (tex.identityMatrix) + { + outMatrix.SetIdentity(); + return false; + } + CopyMatrix(tex.textureMatrix.GetPtr(), outMatrix.GetPtr()); + break; + case kTexGenSphereMap: + { + float invScale = 1.0f / Magnitude (worldViewMatrix.GetAxisX()); + + Matrix4x4f scaleOffsetMatrix; + scaleOffsetMatrix.SetScale(Vector3f(0.5*invScale, 0.5*invScale, 0.0)); + scaleOffsetMatrix.SetPosition(Vector3f(0.5, 0.5, 0.0)); + + Matrix4x4f worldViewMatrixRotation = worldViewMatrix; + worldViewMatrixRotation.SetPosition(Vector3f::zero); + Matrix4x4f combo; + MultiplyMatrices4x4(&scaleOffsetMatrix, &worldViewMatrixRotation, &combo); + MultiplyMatrices4x4(&tex.textureMatrix, &combo, &outMatrix); + break; + } + case kTexGenEyeLinear: + MultiplyMatrices4x4(&tex.textureMatrix, &worldViewMatrix, &outMatrix); + break; + case kTexGenCubeNormal: + case kTexGenCubeReflect: + { + float invScale = 1.0f / Magnitude (worldMatrix.GetAxisX()); + CopyMatrix(worldViewMatrix.GetPtr(), outMatrix.GetPtr()); + outMatrix.Scale(Vector3f(invScale, invScale, invScale)); + outMatrix.SetPosition(Vector3f::zero); + break; + } + default: + ErrorString( Format("Unknown TexGen mode %d", tex.texGen) ); + } + return true; +} + +void VBOContainsColorGLES30(bool flag) +{ + GFX_GL_IMPL& device = static_cast<GFX_GL_IMPL&>(GetRealGfxDevice()); + GetGLES30DeviceState(device).vboContainsColor = flag; +} + +void GLSLUseProgramGLES30(UInt32 programID) +{ + GFX_GL_IMPL& device = static_cast<GFX_GL_IMPL&>(GetRealGfxDevice()); + if (GetGLES30DeviceState(device).activeProgramID == programID) + return; + + GLES_CHK(glUseProgram (programID)); + GetGLES30DeviceState(device).activeProgramID = programID; +} + +static void UploadUniformMatrix4(BuiltinShaderParamIndices::MatrixParamData& matParam, const GpuProgramParameters::ConstantBufferList* constantBuffers, const float* dataPtr, ConstantBuffersGLES30& cbs) +{ + Assert(matParam.cols == 4 && matParam.rows == 4); + if (matParam.cbID == -1) + { + GLES_CHK(glUniformMatrix4fv (matParam.gpuIndex, 1, GL_FALSE, dataPtr)); + } + else if (constantBuffers != NULL) + { + for (int i = 0; i < constantBuffers->size(); ++i) + { + if ((*constantBuffers)[i].m_Name.index == matParam.cbID) + { + const GpuProgramParameters::ConstantBuffer& cb = (*constantBuffers)[i]; + int idx = cbs.FindAndBindCB(cb.m_Name.index, cb.m_BindIndex, cb.m_Size); + cbs.SetCBConstant(idx, matParam.gpuIndex, dataPtr, sizeof(Matrix4x4f)); + break; + } + } + } +} + +static void UploadUniformMatrix3(BuiltinShaderParamIndices::MatrixParamData& matParam, const GpuProgramParameters::ConstantBufferList* constantBuffers, const float* dataPtr, ConstantBuffersGLES30& cbs) +{ + Assert(matParam.cols == 3 && matParam.rows == 3); + if (matParam.cbID == -1) + { + GLES_CHK(glUniformMatrix3fv (matParam.gpuIndex, 1, GL_FALSE, dataPtr)); + } + else if (constantBuffers != NULL) + { + for (int i = 0; i < constantBuffers->size(); ++i) + { + if ((*constantBuffers)[i].m_Name.index == matParam.cbID) + { + const GpuProgramParameters::ConstantBuffer& cb = (*constantBuffers)[i]; + int idx = cbs.FindAndBindCB(cb.m_Name.index, cb.m_BindIndex, cb.m_Size); + cbs.SetCBConstant(idx, matParam.gpuIndex, dataPtr, sizeof(Matrix3x3f)); + break; + } + } + } +} + +void GFX_GL_IMPL::BeforeDrawCall(bool immediateMode) +{ + DBG_LOG_GLES30("BeforeDrawCall(%s)", GetBoolString(immediateMode)); + + ShaderLab::PropertySheet *props = ShaderLab::g_GlobalProperties; + Assert(props); + + // WorldView Matrix + STATE.transformState.UpdateWorldViewMatrix (m_BuiltinParamValues); + + // Materials + if (STATE.lighting) + { + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatEmission, Vector4f(STATE.matEmissive.GetPtr())); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatAmbient, Vector4f(STATE.matAmbient.GetPtr())); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatDiffuse, Vector4f(STATE.matDiffuse.GetPtr())); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatSpecular, Vector4f(STATE.matSpecular.GetPtr())); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatShininess, Vector4f(STATE.matShininess, STATE.matShininess, STATE.matShininess, STATE.matShininess)); + } + + // Fog + if (m_FogParams.mode > kFogDisabled) + { + float diff = m_FogParams.mode == kFogLinear ? m_FogParams.end - m_FogParams.start : 0.0f; + float invDiff = Abs(diff) > 0.0001f ? 1.0f/diff : 0.0f; + + m_BuiltinParamValues.SetVectorParam(kShaderVecFFFogColor, m_FogParams.color); + m_BuiltinParamValues.SetVectorParam(kShaderVecFFFogParams, Vector4f(m_FogParams.density * 1.2011224087f, + m_FogParams.density * 1.4426950408f, + m_FogParams.mode == kFogLinear ? -invDiff : 0.0f, + m_FogParams.mode == kFogLinear ? m_FogParams.end * invDiff : 0.0f + )); + } + + // Alpha-test + m_BuiltinParamValues.SetVectorParam(kShaderVecFFAlphaTestRef, Vector4f(STATE.alphaValue, STATE.alphaValue, STATE.alphaValue, STATE.alphaValue)); + + UniformCacheGLES30* targetCache = 0; + const GpuProgramParameters::ConstantBufferList* constantBuffers = NULL; + if (STATE.activeProgram) + { + // Apply GPU program + GlslGpuProgramGLES30& prog = static_cast<GlslGpuProgramGLES30&>(*STATE.activeProgram); + int fogIndex = prog.ApplyGpuProgramES30 (*STATE.activeProgramParams, STATE.activeProgramParamsBuffer.data()); + constantBuffers = &STATE.activeProgramParams->GetConstantBuffers(); + m_BuiltinParamIndices[kShaderVertex] = &STATE.activeProgramParams->GetBuiltinParams(); + + targetCache = &prog.m_UniformCache[fogIndex]; + } + else + { + // Emulate Fixed Function pipe + m_BuiltinParamValues.SetVectorParam(kShaderVecFFColor, Vector4f(STATE.color.GetPtr())); + for (int i = 0; i < STATE.textureCount; ++i) + { + m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecFFTextureEnvColor0+i), STATE.textures[i].color); + } + + // generate program from fixed function state + DBG_LOG_GLES30(" using fixed-function"); + FixedFunctionStateGLES30 ffstate; + STATE.ComputeFixedFunctionState(ffstate, m_FogParams); + const FixedFunctionProgramGLES30* program = GetFixedFunctionProgram(ffstate); + program->ApplyFFGpuProgram(m_BuiltinParamValues, STATE.m_CBs); + m_BuiltinParamIndices[kShaderVertex] = &program->GetBuiltinParams(); + constantBuffers = &program->GetConstantBuffers(); + + targetCache = &program->m_UniformCache; + } + + // Set Unity built-in parameters + { + Assert(m_BuiltinParamIndices[kShaderVertex]); + const BuiltinShaderParamIndices& params = *m_BuiltinParamIndices[kShaderVertex]; + + // MVP matrix + if (params.mat[kShaderInstanceMatMVP].gpuIndex >= 0) + { + Matrix4x4f wvp; + MultiplyMatrices4x4(&m_BuiltinParamValues.GetMatrixParam(kShaderMatProj), &STATE.transformState.worldViewMatrix, &wvp); + + BuiltinShaderParamIndices::MatrixParamData matParam = params.mat[kShaderInstanceMatMVP]; + Assert(matParam.rows == 4 && matParam.cols == 4); + UploadUniformMatrix4(matParam, constantBuffers, wvp.GetPtr(), STATE.m_CBs); + } + // MV matrix + if (params.mat[kShaderInstanceMatMV].gpuIndex >= 0) + { + BuiltinShaderParamIndices::MatrixParamData matParam = params.mat[kShaderInstanceMatMV]; + Assert(matParam.rows == 4 && matParam.cols == 4); + UploadUniformMatrix4(matParam, constantBuffers, STATE.transformState.worldViewMatrix.GetPtr(), STATE.m_CBs); + } + // Transpose of MV matrix + if (params.mat[kShaderInstanceMatTransMV].gpuIndex >= 0) + { + Matrix4x4f tWV; + TransposeMatrix4x4(&STATE.transformState.worldViewMatrix, &tWV); + + BuiltinShaderParamIndices::MatrixParamData matParam = params.mat[kShaderInstanceMatTransMV]; + Assert(matParam.rows == 4 && matParam.cols == 4); + UploadUniformMatrix4(matParam, constantBuffers, tWV.GetPtr(), STATE.m_CBs); + } + // Inverse transpose of MV matrix + if (params.mat[kShaderInstanceMatInvTransMV].gpuIndex >= 0) + { + // Inverse transpose of modelview should be scaled by uniform + // normal scale (this will match state.matrix.invtrans.modelview + // and gl_NormalMatrix in OpenGL) + Matrix4x4f mat = STATE.transformState.worldViewMatrix; + if (STATE.normalization == kNormalizationScale) + { + float invScale = m_BuiltinParamValues.GetInstanceVectorParam(kShaderInstanceVecScale).w; + mat.Get (0, 0) *= invScale; + mat.Get (1, 0) *= invScale; + mat.Get (2, 0) *= invScale; + mat.Get (0, 1) *= invScale; + mat.Get (1, 1) *= invScale; + mat.Get (2, 1) *= invScale; + mat.Get (0, 2) *= invScale; + mat.Get (1, 2) *= invScale; + mat.Get (2, 2) *= invScale; + } + Matrix4x4f invWV, tInvWV; + Matrix4x4f::Invert_General3D (mat, invWV); + TransposeMatrix4x4(&invWV, &tInvWV); + + BuiltinShaderParamIndices::MatrixParamData matParam = params.mat[kShaderInstanceMatInvTransMV]; + Assert(matParam.rows == 4 && matParam.cols == 4); + UploadUniformMatrix4(matParam, constantBuffers, tInvWV.GetPtr(), STATE.m_CBs); + } + // M matrix + if (params.mat[kShaderInstanceMatM].gpuIndex >= 0) + { + BuiltinShaderParamIndices::MatrixParamData matParam = params.mat[kShaderInstanceMatM]; + const Matrix4x4f& mat = STATE.transformState.worldMatrix; + Assert(matParam.rows == 4 && matParam.cols == 4); + UploadUniformMatrix4(matParam, constantBuffers, mat.GetPtr(), STATE.m_CBs); + } + // Inverse M matrix + if (params.mat[kShaderInstanceMatInvM].gpuIndex >= 0) + { + BuiltinShaderParamIndices::MatrixParamData matParam = params.mat[kShaderInstanceMatInvM]; + Matrix4x4f mat = STATE.transformState.worldMatrix; + if (STATE.normalization == kNormalizationScale) + { + // Kill scale in the world matrix before inverse + float invScale = m_BuiltinParamValues.GetInstanceVectorParam(kShaderInstanceVecScale).w; + mat.Get (0, 0) *= invScale; + mat.Get (1, 0) *= invScale; + mat.Get (2, 0) *= invScale; + mat.Get (0, 1) *= invScale; + mat.Get (1, 1) *= invScale; + mat.Get (2, 1) *= invScale; + mat.Get (0, 2) *= invScale; + mat.Get (1, 2) *= invScale; + mat.Get (2, 2) *= invScale; + } + Matrix4x4f inverseMat; + Matrix4x4f::Invert_General3D (mat, inverseMat); + Assert(matParam.rows == 4 && matParam.cols == 4); + UploadUniformMatrix4(matParam, constantBuffers, inverseMat.GetPtr(), STATE.m_CBs); + } + + // Normal matrix + if (params.mat[kShaderInstanceMatNormalMatrix].gpuIndex >= 0) + { + BuiltinShaderParamIndices::MatrixParamData matParam = params.mat[kShaderInstanceMatNormalMatrix]; + + // @TBD: remove normalization in fixed function emulation after Normal matrix multiply. + Matrix4x4f rotWV; + rotWV = STATE.transformState.worldViewMatrix; + rotWV.SetPosition(Vector3f::zero); // reset translation + + if (STATE.normalization == kNormalizationScale) // reset scale + { + float invScale = m_BuiltinParamValues.GetInstanceVectorParam(kShaderInstanceVecScale).w; + rotWV.Get (0, 0) *= invScale; + rotWV.Get (1, 0) *= invScale; + rotWV.Get (2, 0) *= invScale; + rotWV.Get (0, 1) *= invScale; + rotWV.Get (1, 1) *= invScale; + rotWV.Get (2, 1) *= invScale; + rotWV.Get (0, 2) *= invScale; + rotWV.Get (1, 2) *= invScale; + rotWV.Get (2, 2) *= invScale; + } + Matrix3x3f rotWV33 = Matrix3x3f(rotWV); + UploadUniformMatrix3(matParam, constantBuffers, rotWV33.GetPtr(), STATE.m_CBs); + } + + // Set instance vector parameters + for (int i = 0; i < kShaderInstanceVecCount; ++i) + { + int gpuIndexVS = params.vec[i].gpuIndex; + if (gpuIndexVS >= 0) + { + const float* val = m_BuiltinParamValues.GetInstanceVectorParam((ShaderBuiltinInstanceVectorParam)i).GetPtr(); + switch (params.vec[i].dim) { + case 1: CachedUniform1(targetCache, gpuIndexVS, val); break; + case 2: CachedUniform2(targetCache, gpuIndexVS, val); break; + case 3: CachedUniform3(targetCache, gpuIndexVS, val); break; + case 4: CachedUniform4(targetCache, gpuIndexVS, val); break; + } + GLESAssert(); + } + } + + // Texture Matrices + Matrix4x4f texM; + for (int i = 0; i < kMaxSupportedTextureUnitsGLES; ++i) + { + BuiltinShaderParamIndices::MatrixParamData matParam = params.mat[kShaderInstanceMatTexture0 + i]; + if (matParam.gpuIndex >= 0) + { + if (i < STATE.textureCount) + ComputeTextureTransformMatrix(STATE.textures[i], STATE.transformState.worldViewMatrix, STATE.transformState.worldMatrix, texM); + else + texM.SetIdentity(); + + Assert(matParam.rows == 4 && matParam.cols == 4); + UploadUniformMatrix4(matParam, constantBuffers, texM.GetPtr(), STATE.m_CBs); + } + } + } + + // Set per-drawcall properties + GpuProgram* subprogram = STATE.activeProgram; + if (subprogram) + { + const MaterialPropertyBlock::Property* curProp = STATE.m_MaterialProperties.GetPropertiesBegin(); + const MaterialPropertyBlock::Property* propEnd = STATE.m_MaterialProperties.GetPropertiesEnd(); + const float* propBuffer = STATE.m_MaterialProperties.GetBufferBegin(); + while (curProp != propEnd) + { + FastPropertyName name; + name.index = curProp->nameIndex; + const GpuProgramParameters::ValueParameter* param = STATE.activeProgramParams->FindParam(name); + if (param && curProp->rows == param->m_RowCount) + { + if (curProp->rows == 1) + { + const float* src = &propBuffer[curProp->offset]; + switch (param->m_ColCount) { + case 1: CachedUniform1(targetCache, param->m_Index, src); break; + case 2: CachedUniform2(targetCache, param->m_Index, src); break; + case 3: CachedUniform3(targetCache, param->m_Index, src); break; + case 4: CachedUniform4(targetCache, param->m_Index, src); break; + } + GLESAssert(); + } + else if (curProp->rows == 4) + { + DebugAssert(curProp->cols == 4); + const Matrix4x4f* mat = (const Matrix4x4f*)&propBuffer[curProp->offset]; + GLES_CHK(glUniformMatrix4fv (param->m_Index, 1, GL_FALSE, mat->GetPtr())); + } + else + { + AssertString("Unknown property dimensions"); + } + } + ++curProp; + } + } + STATE.m_MaterialProperties.Clear(); + + STATE.m_CBs.UpdateBuffers (); +} + +bool GFX_GL_IMPL::IsPositionRequiredForTexGen(int unit) const +{ + if (unit >= STATE.textureCount) + return false; + if (STATE.activeProgram) + return false; + + //DebugAssertIf( unit < 0 || unit >= gGraphicsCaps.maxTexUnits); + const TextureUnitStateGLES3& unitState = STATE.textures[unit]; + return TextureUnitStateGLES3::PositionRequiredForTexGen(unitState.texGen); +} + +bool GFX_GL_IMPL::IsNormalRequiredForTexGen(int unit) const +{ + if (unit >= STATE.textureCount) + return false; + if (STATE.activeProgram) + return false; + + //DebugAssertIf( unit < 0 || unit >= gGraphicsCaps.maxTexUnits ); + const TextureUnitStateGLES3& unitState = STATE.textures[unit]; + return TextureUnitStateGLES3::NormalRequiredForTexGen(unitState.texGen); +} + +bool GFX_GL_IMPL::IsPositionRequiredForTexGen() const +{ + return ( STATE.positionTexGen != 0 && !STATE.activeProgram ); +} + +bool GFX_GL_IMPL::IsNormalRequiredForTexGen() const +{ + return ( STATE.normalTexGen != 0 && !STATE.activeProgram ); +} + +void* GFX_GL_IMPL::GetNativeTexturePointer(TextureID id) +{ + return (void*)TextureIdMap::QueryNativeTexture(id); +} + +void GFX_GL_IMPL::ReloadResources() +{ + // Buffers in BufferManager must be cleared before recreating VBOs. + GetBufferManagerGLES30()->InvalidateAll(); + + RecreateAllVBOs(); + GfxDevice::CommonReloadResources(kReleaseRenderTextures | kReloadShaders | kReloadTextures); + ClearFixedFunctionPrograms(); + + if (STATE.m_fboManager) + STATE.m_fboManager->InvalidateObjects(); + + InvalidateState(); +} + +// GPU skinning functionality +GPUSkinningInfo * GFX_GL_IMPL::CreateGPUSkinningInfo() +{ + if (gGraphicsCaps.gles30.useTFSkinning) + return new TransformFeedbackSkinningInfo(); + else + return 0; +} + +void GFX_GL_IMPL::DeleteGPUSkinningInfo(GPUSkinningInfo *info) +{ + delete reinterpret_cast<TransformFeedbackSkinningInfo *>(info); +} + +// All actual functionality is performed in TransformFeedbackSkinningInfo, just forward the calls +void GFX_GL_IMPL::SkinOnGPU( GPUSkinningInfo * info, bool lastThisFrame ) +{ + reinterpret_cast<TransformFeedbackSkinningInfo *>(info)->SkinMesh(lastThisFrame); +} + +void GFX_GL_IMPL::UpdateSkinSourceData(GPUSkinningInfo *info, const void *vertData, const BoneInfluence *skinData, bool dirty) +{ + reinterpret_cast<TransformFeedbackSkinningInfo *>(info)->UpdateSourceData(vertData, skinData, dirty); +} + +void GFX_GL_IMPL::UpdateSkinBonePoses(GPUSkinningInfo *info, const int boneCount, const Matrix4x4f* poses) +{ + reinterpret_cast<TransformFeedbackSkinningInfo *>(info)->UpdateSourceBones(boneCount, poses); +} + +// Acquire thread ownership on the calling thread. Worker releases ownership. +void GFX_GL_IMPL::AcquireThreadOwnership() +{ + AcquireGLES30Context(); +} + +// Release thread ownership on the calling thread. Worker acquires ownership. +void GFX_GL_IMPL::ReleaseThreadOwnership() +{ + ReleaseGLES30Context(); +} + + + +// ---------- verify state +#if GFX_DEVICE_VERIFY_ENABLE +void GFX_GL_IMPL::VerifyState() +{ +} + +#endif // GFX_DEVICE_VERIFY_ENABLE + +#endif // GFX_SUPPORTS_OPENGLES30 |