1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "GLESv2Context.h" 18 #include <string.h> 19 20 void GLESv2Context::init() { 21 emugl::Mutex::AutoLock mutex(s_lock); 22 if(!m_initialized) { 23 s_glDispatch.dispatchFuncs(GLES_2_0); 24 GLEScontext::init(); 25 for(int i=0; i < s_glSupport.maxVertexAttribs;i++){ 26 m_map[i] = new GLESpointer(); 27 } 28 setAttribute0value(0.0, 0.0, 0.0, 1.0); 29 30 buildStrings((const char*)dispatcher().glGetString(GL_VENDOR), 31 (const char*)dispatcher().glGetString(GL_RENDERER), 32 (const char*)dispatcher().glGetString(GL_VERSION), 33 "OpenGL ES 2.0"); 34 } 35 m_initialized = true; 36 } 37 38 GLESv2Context::GLESv2Context():GLEScontext(), m_att0Array(NULL), m_att0ArrayLength(0), m_att0NeedsDisable(false){}; 39 40 GLESv2Context::~GLESv2Context() 41 { 42 delete[] m_att0Array; 43 } 44 45 void GLESv2Context::setAttribute0value(float x, float y, float z, float w) 46 { 47 m_attribute0value[0] = x; 48 m_attribute0value[1] = y; 49 m_attribute0value[2] = z; 50 m_attribute0value[3] = w; 51 } 52 53 void GLESv2Context::validateAtt0PreDraw(unsigned int count) 54 { 55 m_att0NeedsDisable = false; 56 57 if(count == 0) 58 return; 59 60 int enabled = 0; 61 s_glDispatch.glGetVertexAttribiv(0, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &enabled); 62 if(enabled) 63 return; 64 65 if(count > m_att0ArrayLength) 66 { 67 delete [] m_att0Array; 68 m_att0Array = new GLfloat[4*count]; 69 m_att0ArrayLength = count; 70 } 71 72 for(unsigned int i=0; i<count; i++) 73 memcpy(m_att0Array+i*4, m_attribute0value, 4*sizeof(GLfloat)); 74 75 s_glDispatch.glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, m_att0Array); 76 s_glDispatch.glEnableVertexAttribArray(0); 77 78 m_att0NeedsDisable = true; 79 } 80 81 void GLESv2Context::validateAtt0PostDraw(void) 82 { 83 if(m_att0NeedsDisable) 84 s_glDispatch.glDisableVertexAttribArray(0); 85 86 m_att0NeedsDisable = false; 87 } 88 89 void GLESv2Context::setupArraysPointers(GLESConversionArrays& cArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct) { 90 ArraysMap::iterator it; 91 92 //going over all clients arrays Pointers 93 for ( it=m_map.begin() ; it != m_map.end(); it++ ) { 94 GLenum array_id = (*it).first; 95 GLESpointer* p = (*it).second; 96 if(!isArrEnabled(array_id)) continue; 97 98 unsigned int size = p->getSize(); 99 100 if(needConvert(cArrs,first,count,type,indices,direct,p,array_id)){ 101 //conversion has occured 102 ArrayData currentArr = cArrs.getCurrentArray(); 103 setupArr(currentArr.data,array_id,currentArr.type,size,currentArr.stride, p->getNormalized()); 104 ++cArrs; 105 } else { 106 setupArr(p->getData(),array_id,p->getType(), 107 size,p->getStride(), p->getNormalized()); 108 } 109 } 110 } 111 112 //setting client side arr 113 void GLESv2Context::setupArr(const GLvoid* arr,GLenum arrayType,GLenum dataType,GLint size,GLsizei stride,GLboolean normalized, int index){ 114 if(arr == NULL) return; 115 s_glDispatch.glVertexAttribPointer(arrayType,size,dataType,normalized,stride,arr); 116 } 117 118 bool GLESv2Context::needConvert(GLESConversionArrays& cArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct,GLESpointer* p,GLenum array_id) { 119 120 bool usingVBO = p->isVBO(); 121 GLenum arrType = p->getType(); 122 /* 123 conversion is not necessary in the following cases: 124 (*) array type is not fixed 125 */ 126 if(arrType != GL_FIXED) return false; 127 128 if(!usingVBO) { 129 if (direct) { 130 convertDirect(cArrs,first,count,array_id,p); 131 } else { 132 convertIndirect(cArrs,count,type,indices,array_id,p); 133 } 134 } else { 135 if (direct) { 136 convertDirectVBO(cArrs,first,count,array_id,p) ; 137 } else { 138 convertIndirectVBO(cArrs,count,type,indices,array_id,p); 139 } 140 } 141 return true; 142 } 143 144 void GLESv2Context::initExtensionString() { 145 *s_glExtensions = "GL_OES_EGL_image GL_OES_depth24 GL_OES_depth32 GL_OES_element_index_uint " 146 "GL_OES_texture_float GL_OES_texture_float_linear " 147 "GL_OES_compressed_paletted_texture GL_OES_compressed_ETC1_RGB8_texture GL_OES_depth_texture "; 148 if (s_glSupport.GL_ARB_HALF_FLOAT_PIXEL || s_glSupport.GL_NV_HALF_FLOAT) 149 *s_glExtensions+="GL_OES_texture_half_float GL_OES_texture_half_float_linear "; 150 if (s_glSupport.GL_EXT_PACKED_DEPTH_STENCIL) 151 *s_glExtensions+="GL_OES_packed_depth_stencil "; 152 if (s_glSupport.GL_ARB_HALF_FLOAT_VERTEX) 153 *s_glExtensions+="GL_OES_vertex_half_float "; 154 if (s_glSupport.GL_OES_STANDARD_DERIVATIVES) 155 *s_glExtensions+="GL_OES_standard_derivatives "; 156 } 157 158 int GLESv2Context::getMaxTexUnits() { 159 return getCaps()->maxTexImageUnits; 160 } 161