| /* |
| * Copyright (C) 2014 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "gles/uniform_value.h" |
| |
| #include <algorithm> |
| #include "common/alog.h" |
| #include "gles/debug.h" |
| #include "gles/gles_context.h" |
| #include "gles/macros.h" |
| |
| UniformValue::UniformValue(GLenum type, bool is_array, GLint array_size) |
| : type_(type), is_array_(is_array), array_size_(array_size) { |
| InitData(reinterpret_cast<GLfloat*>(NULL)); |
| } |
| |
| UniformValue::UniformValue(GLenum type, bool is_array, GLint array_size, |
| const GLfloat* value) |
| : type_(type), is_array_(is_array), array_size_(array_size) { |
| InitData(value); |
| LOG_ALWAYS_FATAL_IF(data_type_ != DATA_FLOAT && data_type_ != DATA_BOOL && |
| data_type_ != DATA_MATRIX); |
| } |
| |
| UniformValue::UniformValue(GLenum type, bool is_array, GLint array_size, |
| const GLint* value) |
| : type_(type), is_array_(is_array), array_size_(array_size) { |
| InitData(value); |
| LOG_ALWAYS_FATAL_IF(data_type_ != DATA_INT && data_type_ != DATA_BOOL && |
| data_type_ != DATA_SAMPLER); |
| } |
| |
| UniformValue::~UniformValue() { |
| delete[] value_; |
| } |
| |
| template<typename T> |
| void UniformValue::InitData(const T* initial_value) { |
| switch (type_) { |
| case GL_FLOAT: |
| data_type_ = DATA_FLOAT; |
| components_ = 1; |
| break; |
| case GL_FLOAT_VEC2: |
| data_type_ = DATA_FLOAT; |
| components_ = 2; |
| break; |
| case GL_FLOAT_VEC3: |
| data_type_ = DATA_FLOAT; |
| components_ = 3; |
| break; |
| case GL_FLOAT_VEC4: |
| data_type_ = DATA_FLOAT; |
| components_ = 4; |
| break; |
| case GL_INT: |
| data_type_ = DATA_INT; |
| components_ = 1; |
| break; |
| case GL_INT_VEC2: |
| data_type_ = DATA_INT; |
| components_ = 2; |
| break; |
| case GL_INT_VEC3: |
| data_type_ = DATA_INT; |
| components_ = 3; |
| break; |
| case GL_INT_VEC4: |
| data_type_ = DATA_INT; |
| components_ = 4; |
| break; |
| case GL_BOOL: |
| data_type_ = DATA_BOOL; |
| components_ = 1; |
| break; |
| case GL_BOOL_VEC2: |
| data_type_ = DATA_BOOL; |
| components_ = 2; |
| break; |
| case GL_BOOL_VEC3: |
| data_type_ = DATA_BOOL; |
| components_ = 3; |
| break; |
| case GL_BOOL_VEC4: |
| data_type_ = DATA_BOOL; |
| components_ = 4; |
| break; |
| case GL_FLOAT_MAT2: |
| data_type_ = DATA_MATRIX; |
| components_ = 2 * 2; |
| break; |
| case GL_FLOAT_MAT3: |
| data_type_ = DATA_MATRIX; |
| components_ = 3 * 3; |
| break; |
| case GL_FLOAT_MAT4: |
| data_type_ = DATA_MATRIX; |
| components_ = 4 * 4; |
| break; |
| case GL_SAMPLER_2D: |
| case GL_SAMPLER_CUBE: |
| data_type_ = DATA_SAMPLER; |
| components_ = 1; |
| break; |
| default: |
| LOG_ALWAYS_FATAL("Unknown uniform type %s", GetEnumString(type_)); |
| } |
| |
| LOG_ALWAYS_FATAL_IF(array_size_ < 0, "Uniform array size is negative: %d", |
| array_size_); |
| |
| element_bytes_size_ = components_ * |
| (IsFloatData() ? sizeof(GLfloat) : sizeof(GLint)); |
| |
| value_ = new char[GetStorageBytesSize()]; |
| |
| if (initial_value) { |
| if (data_type_ == DATA_BOOL) { |
| for (int i = 0; i < array_size_; ++i) { |
| SetBoolElementFrom(i, initial_value + i); |
| } |
| } else { |
| memcpy(value_, initial_value, GetStorageBytesSize()); |
| } |
| } else { |
| ResetData(); |
| } |
| } |
| |
| void UniformValue::ResetData() { |
| memset(value_, 0, GetStorageBytesSize()); |
| } |
| |
| int UniformValue::GetArrayPos(int idx) const { |
| LOG_ALWAYS_FATAL_IF(idx < 0 || idx >= array_size_); |
| return idx * element_bytes_size_; |
| } |
| |
| bool UniformValue::CopyFrom(const UniformValue& src) { |
| ResetData(); |
| const int size_to_copy = std::min(array_size_, src.array_size_); |
| for (int i = 0; i < size_to_copy; ++i) { |
| if (!CopyElementFrom(i, src, i)) { |
| // When data is not convertible, the first call to CopyElementFrom() |
| // will fail, leaving destination object filled with zeroes. |
| // This should be OK as GLES2 is silent on this topic. |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| bool UniformValue::CopyElementFrom(int dst_idx, const UniformValue& src, |
| int src_idx) { |
| const int dst_pos = GetArrayPos(dst_idx); |
| const int src_pos = src.GetArrayPos(src_idx); |
| |
| if (components_ != src.components_) { |
| // GLES2 prescribes an error "if the size indicated in the name of |
| // the Uniform* command used does not match the size of the uniform |
| // declared in the shader". The components size of sampler uniform |
| // is assumed to be 1, as only glUniform1iv() can be used there. |
| #ifdef ENABLE_API_LOGGING |
| ALOGW("Unable to convert uniform value. Src=%d/%d. Dst=%d/%d", |
| src.data_type_, src.components_, data_type_, components_); |
| #endif |
| return false; |
| } |
| |
| if (data_type_ == src.data_type_) { |
| // Same general type and components size - copy the element as is. |
| memcpy(value_ + dst_pos, src.value_ + src_pos, element_bytes_size_); |
| return true; |
| } |
| |
| // The rest of the code performs data type conversions. |
| |
| if (data_type_ == DATA_MATRIX || src.data_type_ == DATA_MATRIX) { |
| // GLES2 does not allow conversion between matrix and non-matrix types. |
| #ifdef ENABLE_API_LOGGING |
| ALOGW("Unable to convert uniform value. Src=%d/%d. Dst=%d/%d", |
| src.data_type_, src.components_, data_type_, components_); |
| #endif |
| return false; |
| } |
| |
| if (src.data_type_ == DATA_BOOL) { |
| // Bool data can be converted to int or float. |
| if (data_type_ == DATA_SAMPLER) { |
| #ifdef ENABLE_API_LOGGING |
| ALOGW("Unable to convert uniform value. Src=%d/%d. Dst=%d/%d", |
| src.data_type_, src.components_, data_type_, components_); |
| #endif |
| return false; |
| } |
| LOG_ALWAYS_FATAL_IF(data_type_ != DATA_INT && |
| data_type_ != DATA_FLOAT); |
| if (IsFloatData()) { |
| src.StoreBoolElementTo( |
| reinterpret_cast<GLfloat*>(value_ + dst_pos), src_idx); |
| } else { |
| src.StoreBoolElementTo( |
| reinterpret_cast<GLint*>(value_ + dst_pos), src_idx); |
| } |
| return true; |
| } |
| |
| if (data_type_ == DATA_BOOL) { |
| // Int or float data can be converted to bool. |
| if (src.data_type_ == DATA_SAMPLER) { |
| #ifdef ENABLE_API_LOGGING |
| ALOGW("Unable to convert uniform value. Src=%d/%d. Dst=%d/%d", |
| src.data_type_, src.components_, data_type_, components_); |
| #endif |
| return false; |
| } |
| LOG_ALWAYS_FATAL_IF(src.data_type_ != DATA_INT && |
| src.data_type_ != DATA_FLOAT); |
| if (src.IsFloatData()) { |
| SetBoolElementFrom( |
| dst_idx, reinterpret_cast<const GLfloat*>(src.value_ + src_pos)); |
| } else { |
| SetBoolElementFrom( |
| dst_idx, reinterpret_cast<const GLint*>(src.value_ + src_pos)); |
| } |
| return true; |
| } |
| |
| if (src.data_type_ == DATA_SAMPLER) { |
| // Sampler data can be converted to int. |
| if (IsFloatData()) { |
| #ifdef ENABLE_API_LOGGING |
| ALOGW("Unable to convert uniform value. Src=%d/%d. Dst=%d/%d", |
| src.data_type_, src.components_, data_type_, components_); |
| #endif |
| return false; |
| } |
| LOG_ALWAYS_FATAL_IF(data_type_ != DATA_INT); |
| memcpy(value_ + dst_pos, src.value_ + src_pos, element_bytes_size_); |
| return true; |
| } |
| |
| if (data_type_ == DATA_SAMPLER) { |
| // Int data can be converted to sampler data. |
| if (src.IsFloatData()) { |
| #ifdef ENABLE_API_LOGGING |
| ALOGW("Unable to convert uniform value. Src=%d/%d. Dst=%d/%d", |
| src.data_type_, src.components_, data_type_, components_); |
| #endif |
| return false; |
| } |
| LOG_ALWAYS_FATAL_IF(src.data_type_ != DATA_INT); |
| memcpy(value_ + dst_pos, src.value_ + src_pos, element_bytes_size_); |
| return true; |
| } |
| |
| // No other conversions are allowed by GLES2. |
| #ifdef ENABLE_API_LOGGING |
| ALOGW("Unable to convert uniform value. Src=%d/%d. Dst=%d/%d", |
| src.data_type_, src.components_, data_type_, components_); |
| #endif |
| return false; |
| } |
| |
| template<typename T> |
| void UniformValue::StoreBoolElementTo(T* dst, int idx) const { |
| LOG_ALWAYS_FATAL_IF(data_type_ != DATA_BOOL); |
| const GLint* src = reinterpret_cast<const GLint*>( |
| value_ + GetArrayPos(idx)); |
| for (int i = 0; i < components_; ++i) { |
| dst[i] = (src[i] != 0); |
| } |
| } |
| |
| template<typename T> |
| void UniformValue::SetBoolElementFrom(int idx, const T* src) { |
| LOG_ALWAYS_FATAL_IF(data_type_ != DATA_BOOL); |
| GLint* dst = reinterpret_cast<GLint*>(value_ + GetArrayPos(idx)); |
| for (int i = 0; i < components_; ++i) { |
| dst[i] = (src[i] != 0); |
| } |
| } |
| |
| bool UniformValue::StoreAsFloatTo(GLfloat* value) const { |
| if (data_type_ == DATA_BOOL) { |
| for (int i = 0; i < array_size_; ++i) { |
| StoreBoolElementTo(value + i * components_, i); |
| } |
| return true; |
| } |
| |
| if (!IsFloatData()) { |
| // Int or sampler. Only bool or float-based data can be requested here. |
| return false; |
| } |
| |
| memcpy(value, value_, GetStorageBytesSize()); |
| return true; |
| } |
| |
| bool UniformValue::StoreAsIntTo(GLint* value) const { |
| if (data_type_ == DATA_BOOL) { |
| for (int i = 0; i < array_size_; ++i) { |
| StoreBoolElementTo(value + i * components_, i); |
| } |
| return true; |
| } |
| |
| if (IsFloatData()) { |
| // Float or matrix. However, only bool and sampler conversions are allowed |
| // for int type by GLES2. |
| return false; |
| } |
| |
| memcpy(value, value_, GetStorageBytesSize()); |
| return true; |
| } |
| |
| void UniformValue::SetOnProgram(GlesContext* ctx, |
| GLuint location) const { |
| if (!array_size_) { |
| return; |
| } |
| const GLint* int_value = reinterpret_cast<const GLint*>(value_); |
| const GLfloat* float_value = reinterpret_cast<const GLfloat*>(value_); |
| switch (type_) { |
| case GL_FLOAT: |
| PASS_THROUGH(ctx, Uniform1fv, location, array_size_, float_value); |
| break; |
| case GL_FLOAT_VEC2: |
| PASS_THROUGH(ctx, Uniform2fv, location, array_size_, float_value); |
| break; |
| case GL_FLOAT_VEC3: |
| PASS_THROUGH(ctx, Uniform3fv, location, array_size_, float_value); |
| break; |
| case GL_FLOAT_VEC4: |
| PASS_THROUGH(ctx, Uniform4fv, location, array_size_, float_value); |
| break; |
| case GL_INT: |
| case GL_BOOL: |
| case GL_SAMPLER_2D: |
| case GL_SAMPLER_CUBE: |
| PASS_THROUGH(ctx, Uniform1iv, location, array_size_, int_value); |
| break; |
| case GL_INT_VEC2: |
| case GL_BOOL_VEC2: |
| PASS_THROUGH(ctx, Uniform2iv, location, array_size_, int_value); |
| break; |
| case GL_INT_VEC3: |
| case GL_BOOL_VEC3: |
| PASS_THROUGH(ctx, Uniform3iv, location, array_size_, int_value); |
| break; |
| case GL_INT_VEC4: |
| case GL_BOOL_VEC4: |
| PASS_THROUGH(ctx, Uniform4iv, location, array_size_, int_value); |
| break; |
| case GL_FLOAT_MAT2: |
| PASS_THROUGH(ctx, UniformMatrix2fv, location, array_size_, |
| GL_FALSE, float_value); |
| break; |
| case GL_FLOAT_MAT3: |
| PASS_THROUGH(ctx, UniformMatrix3fv, location, array_size_, |
| GL_FALSE, float_value); |
| break; |
| case GL_FLOAT_MAT4: |
| PASS_THROUGH(ctx, UniformMatrix4fv, location, array_size_, |
| GL_FALSE, float_value); |
| break; |
| default: |
| LOG_ALWAYS_FATAL("Unknown uniform type %s", GetEnumString(type_)); |
| } |
| } |
