#include "base/time/time.h"
#include "gpu/command_buffer/common/gles2_cmd_format.h"
#include "gpu/command_buffer/common/gles2_cmd_utils.h"
-#include "gpu/command_buffer/service/feature_info.h"
#include "gpu/command_buffer/service/gles2_cmd_decoder.h"
#include "gpu/command_buffer/service/gpu_switches.h"
#include "gpu/command_buffer/service/program_cache.h"
is_array(false) {
}
-Program::UniformInfo::UniformInfo(
- GLsizei _size,
- GLenum _type,
- int _fake_location_base,
- const std::string& _name)
+Program::UniformInfo::UniformInfo(GLsizei _size,
+ GLenum _type,
+ int _fake_location_base,
+ const std::string& _name)
: size(_size),
type(_type),
+ accepts_api_type(0),
fake_location_base(_fake_location_base),
is_array(false),
name(_name) {
+ switch (type) {
+ case GL_INT:
+ accepts_api_type = kUniform1i;
+ break;
+ case GL_INT_VEC2:
+ accepts_api_type = kUniform2i;
+ break;
+ case GL_INT_VEC3:
+ accepts_api_type = kUniform3i;
+ break;
+ case GL_INT_VEC4:
+ accepts_api_type = kUniform4i;
+ break;
+
+ case GL_BOOL:
+ accepts_api_type = kUniform1i | kUniform1f;
+ break;
+ case GL_BOOL_VEC2:
+ accepts_api_type = kUniform2i | kUniform2f;
+ break;
+ case GL_BOOL_VEC3:
+ accepts_api_type = kUniform3i | kUniform3f;
+ break;
+ case GL_BOOL_VEC4:
+ accepts_api_type = kUniform4i | kUniform4f;
+ break;
+
+ case GL_FLOAT:
+ accepts_api_type = kUniform1f;
+ break;
+ case GL_FLOAT_VEC2:
+ accepts_api_type = kUniform2f;
+ break;
+ case GL_FLOAT_VEC3:
+ accepts_api_type = kUniform3f;
+ break;
+ case GL_FLOAT_VEC4:
+ accepts_api_type = kUniform4f;
+ break;
+
+ case GL_FLOAT_MAT2:
+ accepts_api_type = kUniformMatrix2f;
+ break;
+ case GL_FLOAT_MAT3:
+ accepts_api_type = kUniformMatrix3f;
+ break;
+ case GL_FLOAT_MAT4:
+ accepts_api_type = kUniformMatrix4f;
+ break;
+
+ case GL_SAMPLER_2D:
+ case GL_SAMPLER_2D_RECT_ARB:
+ case GL_SAMPLER_CUBE:
+ case GL_SAMPLER_3D_OES:
+ case GL_SAMPLER_EXTERNAL_OES:
+ accepts_api_type = kUniform1i;
+ break;
+ default:
+ NOTREACHED() << "Unhandled UniformInfo type " << type;
+ break;
+ }
}
Program::UniformInfo::~UniformInfo() {}
}
}
-void ProgramManager::DoCompileShader(Shader* shader,
- ShaderTranslator* translator,
- FeatureInfo* feature_info) {
- // Translate GL ES 2.0 shader to Desktop GL shader and pass that to
- // glShaderSource and then glCompileShader.
- const std::string* source = shader->source();
- const char* shader_src = source ? source->c_str() : "";
- if (translator) {
- if (!translator->Translate(shader_src)) {
- shader->SetStatus(false, translator->info_log(), NULL);
- return;
- }
- shader_src = translator->translated_shader();
- if (!feature_info->feature_flags().angle_translated_shader_source)
- shader->UpdateTranslatedSource(shader_src);
- }
-
- glShaderSource(shader->service_id(), 1, &shader_src, NULL);
- glCompileShader(shader->service_id());
- if (feature_info->feature_flags().angle_translated_shader_source) {
- GLint max_len = 0;
- glGetShaderiv(shader->service_id(),
- GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE,
- &max_len);
- scoped_ptr<char[]> temp(new char[max_len]);
- GLint len = 0;
- glGetTranslatedShaderSourceANGLE(
- shader->service_id(), max_len, &len, temp.get());
- DCHECK(max_len == 0 || len < max_len);
- DCHECK(len == 0 || temp[len] == '\0');
- shader->UpdateTranslatedSource(max_len ? temp.get() : NULL);
- }
-
- GLint status = GL_FALSE;
- glGetShaderiv(shader->service_id(), GL_COMPILE_STATUS, &status);
- if (status) {
- shader->SetStatus(true, "", translator);
- } else {
- // We cannot reach here if we are using the shader translator.
- // All invalid shaders must be rejected by the translator.
- // All translated shaders must compile.
- GLint max_len = 0;
- glGetShaderiv(shader->service_id(), GL_INFO_LOG_LENGTH, &max_len);
- scoped_ptr<char[]> temp(new char[max_len]);
- GLint len = 0;
- glGetShaderInfoLog(shader->service_id(), max_len, &len, temp.get());
- DCHECK(max_len == 0 || len < max_len);
- DCHECK(len == 0 || temp[len] == '\0');
- shader->SetStatus(false, std::string(temp.get(), len).c_str(), NULL);
- LOG_IF(ERROR, translator)
- << "Shader translator allowed/produced an invalid shader "
- << "unless the driver is buggy:"
- << "\n--original-shader--\n" << (source ? *source : std::string())
- << "\n--translated-shader--\n" << shader_src << "\n--info-log--\n"
- << *shader->log_info();
- }
-}
-
bool Program::Link(ShaderManager* manager,
ShaderTranslator* vertex_translator,
ShaderTranslator* fragment_translator,
- FeatureInfo* feature_info,
+ Program::VaryingsPackingOption varyings_packing_option,
const ShaderCacheCallback& shader_callback) {
ClearLinkStatus();
if (!CanLink()) {
set_log_info(ProcessLogInfo(info_log).c_str());
return false;
}
- if (!CheckVaryingsPacking()) {
+ if (!CheckVaryingsPacking(varyings_packing_option)) {
set_log_info("Varyings over maximum register limit");
return false;
}
bool link = true;
ProgramCache* cache = manager_->program_cache_;
if (cache) {
- DCHECK(attached_shaders_[0]->signature_source() &&
- attached_shaders_[1]->signature_source());
+ DCHECK(!attached_shaders_[0]->signature_source().empty() &&
+ !attached_shaders_[1]->signature_source().empty());
ProgramCache::LinkedProgramStatus status = cache->GetLinkedProgramStatus(
- *attached_shaders_[0]->signature_source(),
+ attached_shaders_[0]->signature_source(),
vertex_translator,
- *attached_shaders_[1]->signature_source(),
+ attached_shaders_[1]->signature_source(),
fragment_translator,
&bind_attrib_location_map_);
bool Program::CanLink() const {
for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
- if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->IsValid()) {
+ if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->valid()) {
return false;
}
}
// Find out if an attribute is declared in this program's shaders.
bool active = false;
for (int ii = 0; ii < kMaxAttachedShaders; ++ii) {
- if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->IsValid())
+ if (!attached_shaders_[ii].get() || !attached_shaders_[ii]->valid())
continue;
if (attached_shaders_[ii]->GetAttribInfo(it->first)) {
active = true;
}
bool Program::DetectVaryingsMismatch(std::string* conflicting_name) const {
- DCHECK(attached_shaders_[0] &&
+ DCHECK(attached_shaders_[0].get() &&
attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
- attached_shaders_[1] &&
+ attached_shaders_[1].get() &&
attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
const ShaderTranslator::VariableMap* vertex_varyings =
&(attached_shaders_[0]->varying_map());
}
bool Program::DetectGlobalNameConflicts(std::string* conflicting_name) const {
- DCHECK(attached_shaders_[0] &&
+ DCHECK(attached_shaders_[0].get() &&
attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
- attached_shaders_[1] &&
+ attached_shaders_[1].get() &&
attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
const ShaderTranslator::VariableMap* uniforms[2];
uniforms[0] = &(attached_shaders_[0]->uniform_map());
return false;
}
-bool Program::CheckVaryingsPacking() const {
- DCHECK(attached_shaders_[0] &&
+bool Program::CheckVaryingsPacking(
+ Program::VaryingsPackingOption option) const {
+ DCHECK(attached_shaders_[0].get() &&
attached_shaders_[0]->shader_type() == GL_VERTEX_SHADER &&
- attached_shaders_[1] &&
+ attached_shaders_[1].get() &&
attached_shaders_[1]->shader_type() == GL_FRAGMENT_SHADER);
const ShaderTranslator::VariableMap* vertex_varyings =
&(attached_shaders_[0]->varying_map());
for (ShaderTranslator::VariableMap::const_iterator iter =
fragment_varyings->begin();
iter != fragment_varyings->end(); ++iter) {
- if (!iter->second.static_use)
+ if (!iter->second.static_use && option == kCountOnlyStaticallyUsed)
continue;
if (!IsBuiltInVarying(iter->first)) {
ShaderTranslator::VariableMap::const_iterator vertex_iter =
vertex_varyings->find(iter->first);
if (vertex_iter == vertex_varyings->end() ||
- !vertex_iter->second.static_use)
+ (!vertex_iter->second.static_use &&
+ option == kCountOnlyStaticallyUsed))
continue;
}
ShVariableInfo var;
- var.type = static_cast<ShDataType>(iter->second.type);
+ var.type = static_cast<sh::GLenum>(iter->second.type);
var.size = iter->second.size;
combined_map[iter->first] = var;
}
uint32 max_varying_vectors)
: program_count_(0),
have_context_(true),
- disable_workarounds_(
- CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kDisableGpuDriverBugWorkarounds)),
program_cache_(program_cache),
max_varying_vectors_(max_varying_vectors) { }
DCHECK(program);
DCHECK(IsOwned(program));
program->IncUseCount();
- ClearUniforms(program);
}
void ProgramManager::UnuseProgram(
void ProgramManager::ClearUniforms(Program* program) {
DCHECK(program);
- if (!disable_workarounds_) {
- program->ClearUniforms(&zero_);
- }
+ program->ClearUniforms(&zero_);
}
int32 ProgramManager::MakeFakeLocation(int32 index, int32 element) {
projects / platform / framework / web / crosswalk.git / blobdiff