void ColorPicker::_notification(int p_what) {
switch(p_what) {
case NOTIFICATION_THEME_CHANGED: {
uv_material->set_shader(get_shader("uv_editor"));
w_material->set_shader(get_shader("w_editor"));
update_material(uv_material,color,h,s,v);
update_material(w_material,color,h,s,v);
_update_controls();
} break;
case NOTIFICATION_ENTER_TREE: {
btn_pick->set_icon(get_icon("screen_picker", "ColorPicker"));
update_material(uv_material, color,h,s,v);
update_material(w_material, color,h,s,v);
uv_edit->get_child(0)->cast_to<Control>()->update();
w_edit->get_child(0)->cast_to<Control>()->update();
_update_color();
}
case NOTIFICATION_VISIBILITY_CHANGED: {
c_text->call_deferred("grab_focus");
c_text->call_deferred("select");
} break;
}
}
static GLuint
build_shaders(const char *vs_prefix, int vs_blocks,
const char *fs_prefix, int fs_blocks)
{
char *vs_source, *fs_source;
GLuint vs, fs, prog;
vs_source = get_shader(GL_VERTEX_SHADER, vs_prefix, vs_blocks);
fs_source = get_shader(GL_FRAGMENT_SHADER, fs_prefix, fs_blocks);
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source);
fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_source);
prog = glCreateProgram();
glAttachShader(prog, vs);
glAttachShader(prog, fs);
glLinkProgram(prog);
if (!piglit_link_check_status_quiet(prog)) {
glDeleteProgram(prog);
prog = 0;
}
glDeleteShader(vs);
glDeleteShader(fs);
return prog;
}
GLuint load_shader_for_object(struct d3_object * object)
{
//printf("load_shader_for_object\n");
int i = 0;
GLuint shader_program;
int num_lights = 0;
if (object->affected_lights != NULL){
//printf("affected_lights IS NOT NULL\n");
num_lights = object->affected_lights->size();
}
//printf("num_lights %i, i: %i\n", num_lights, i);
int shadow_lights = 0;
int noshadow_lights = 0;
int nospecular_lights = 0;
bool cast_shadows = false;
/* check to see if one of the lights is a shadow casting one */
for (i=0; i < num_lights; i++)
{
//printf("num_lights %i, i: %i\n", num_lights, i);
if ((*object->affected_lights)[i]->cast_shadows) {
cast_shadows = true;
shadow_lights++;
break;
}
}
noshadow_lights = num_lights - shadow_lights;
//shadow_lights = 0; /*test */
shader_program = get_shader(shadow_lights, noshadow_lights, nospecular_lights);
//printf("shader loaded:(%i, %i, %i)\n", shadow_lights, noshadow_lights, nospecular_lights);
glUseProgram(shader_program);
return shader_program;
}
static void set_view_projection_uniforms(const glm::mat4& view, const glm::mat4& projection) {
Assert(current_shader_asset != -1);
shader_asset* shader = get_shader(current_shader_asset);
Assert(shader);
set_uniform_matrix4(shader->projection_uniform, projection);
set_uniform_matrix4(shader->view_uniform, view);
}
void GPUPipeline::bind_shader_input(Buffer& buff,
const std::string& input, long offset,
GLsizei stride)
{
const Shader::InputDef& def = get_shader().get_input(input);
bind_shader_input(buff, def, offset, stride);
}
int fd_program_attach_asm(struct fd_program *program,
enum fd_shader_type type, const char *src)
{
struct fd_shader *shader = get_shader(program, type);
int sizedwords;
if (shader->ir)
ir3_shader_destroy(shader->ir);
memset(shader, 0, sizeof(*shader));
shader->ir = fd_asm_parse(src);
if (!shader->ir) {
ERROR_MSG("parse failed");
return -1;
}
sizedwords = ir3_shader_assemble(shader->ir, shader->bin,
ARRAY_SIZE(shader->bin), &shader->info);
if (sizedwords <= 0) {
ERROR_MSG("assembler failed");
return -1;
}
shader->sizedwords = sizedwords;
return 0;
}
bool CanvasItemMaterial::_get(const StringName& p_name,Variant &r_ret) const {
if (p_name==SceneStringNames::get_singleton()->shader_shader) {
r_ret=get_shader();
return true;
} else if (p_name==SceneStringNames::get_singleton()->shading_mode) {
r_ret=shading_mode;
return true;
} else {
if (shader.is_valid()) {
StringName pr = shader->remap_param(p_name);
if (pr) {
r_ret=VisualServer::get_singleton()->canvas_item_material_get_shader_param(material,pr);
return true;
}
}
}
return false;
}
complex las_accel(Laser *l, float t) {
if(t == EVENT_BIRTH) {
l->shader = get_shader("laser_accelerated");
return 0;
}
return l->pos + l->args[0]*t + 0.5*l->args[1]*t*t;
}
uint32_t fd_program_outloc(struct fd_program *program)
{
struct fd_shader *vs = get_shader(program, FD_SHADER_VERTEX);
/* we only support vec4 varyings, otherwise we'd have to
* count 'em up:
*/
return 8 + (4 * vs->ir->varyings_count);
}
void
piglit_init(int argc, char **argv)
{
enum test_array_type array_type;
GLint max_varying_floats;
struct varying_desc *varyings;
unsigned num_varyings;
unsigned glsl_version;
GLuint vs, fs;
if (argc != 3)
print_usage_and_exit(argv[0]);
glsl_version = test_type->glsl_version_required;
if (strcmp(argv[2], "array") == 0)
array_type = ARRAY;
else if (strcmp(argv[2], "separate") == 0)
array_type = SEPARATE;
else if (strcmp(argv[2], "arrays_of_arrays") == 0) {
array_type = ARRAYS_OF_ARRAYS;
piglit_require_extension("GL_ARB_arrays_of_arrays");
if (glsl_version < 120)
glsl_version = 120;
} else
print_usage_and_exit(argv[0]);
piglit_require_gl_version(20);
piglit_require_GLSL_version(glsl_version);
if (test_type->base == BASE_TYPE_DOUBLE)
piglit_require_extension("GL_ARB_gpu_shader_fp64");
glGetIntegerv(GL_MAX_VARYING_FLOATS, &max_varying_floats);
varyings = malloc(sizeof(*varyings) * max_varying_floats);
num_varyings = choose_varyings(varyings, test_type,
array_type, max_varying_floats);
vs = get_shader(true, test_type->glsl_version_required,
num_varyings, varyings, array_type);
fs = get_shader(false, test_type->glsl_version_required,
num_varyings, varyings, array_type);
prog = piglit_link_simple_program(vs, fs);
i_location = glGetUniformLocation(prog, "i");
free(varyings);
}
complex las_linear(Laser *l, float t) {
if(t == EVENT_BIRTH) {
l->shader = get_shader("laser_linear");
l->collision_step = l->timespan;
return 0;
}
return l->pos + l->args[0]*t;
}
complex las_sine_expanding(Laser *l, float t) { // [0] = velocity; [1] = sine amplitude; [2] = sine frequency; [3] = sine phase
if(t == EVENT_BIRTH) {
l->shader = get_shader("laser_sine_expanding");
return 0;
}
double s = (l->args[2] * t + l->args[3]);
return l->pos + cexp(I * (carg(l->args[0]) + l->args[1] * sin(s))) * t * cabs(l->args[0]);
}
void
piglit_init(int argc, char **argv)
{
unsigned i;
const struct type_desc *test_type;
GLboolean test_array;
GLint max_varying_floats;
struct varying_desc *varyings;
unsigned num_varyings;
GLuint vs, fs;
if (argc != 3)
print_usage_and_exit(argv[0]);
for (i = 0; all_types[i]; ++i) {
if (strcmp(argv[1], all_types[i]->name) == 0)
break;
}
if (all_types[i])
test_type = all_types[i];
else
print_usage_and_exit(argv[0]);
if (strcmp(argv[2], "array") == 0)
test_array = GL_TRUE;
else if (strcmp(argv[2], "separate") == 0)
test_array = GL_FALSE;
else
print_usage_and_exit(argv[0]);
piglit_require_gl_version(20);
piglit_require_GLSL_version(test_type->glsl_version_required);
glGetIntegerv(GL_MAX_VARYING_FLOATS, &max_varying_floats);
varyings = malloc(sizeof(*varyings) * max_varying_floats);
num_varyings = choose_varyings(varyings, test_type,
test_array, max_varying_floats);
vs = get_shader(true, test_type->glsl_version_required,
num_varyings, varyings);
fs = get_shader(false, test_type->glsl_version_required,
num_varyings, varyings);
prog = piglit_link_simple_program(vs, fs);
i_location = glGetUniformLocation(prog, "i");
free(varyings);
}
bool Shader::add(OSL::ShadingSystem& shading_system)
{
for (each<ShaderParamContainer> i = impl->m_params; i; ++i)
{
if (!i->add(shading_system))
return false;
}
// For some reason, OSL only supports the surface shader usage.
// So, we ignore the user shader type specified in the XML file,
// and hardcode "surface" here. TODO: research this...
//if (!shading_system.Shader(get_type(), get_shader(), get_layer()))
if (!shading_system.Shader("surface", get_shader(), get_layer()))
{
RENDERER_LOG_ERROR("error adding shader %s, %s.", get_shader(), get_layer());
return false;
}
return true;
}
void FeImage::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
FeShader *s = get_shader();
if ( s )
{
const sf::Shader *sh = s->get_shader();
if ( sh )
states.shader = sh;
}
target.draw( m_sprite, states );
}
void FeListBox::draw( sf::RenderTarget &target, sf::RenderStates states ) const
{
FeShader *s = get_shader();
if ( s )
{
const sf::Shader *sh = s->get_shader();
if ( sh )
states.shader = sh;
}
for ( std::vector<FeTextPrimative>::const_iterator itl=m_texts.begin();
itl != m_texts.end(); ++itl )
target.draw( (*itl), states );
}
void draw_ingame_menu_bg(float f) {
float rad = f*IMENU_BLUR;
if(!tconfig.intval[NO_SHADER]) {
glBindFramebuffer(GL_FRAMEBUFFER, 0);
Shader *shader = get_shader("ingame_menu");
glUseProgram(shader->prog);
glUniform1f(uniloc(shader, "rad"), rad);
draw_fbo_viewport(&resources.fsec);
glUseProgram(0);
}
}
void _ProjDraw(Projectile *proj, int t) {
if(proj->clr != NULL && !tconfig.intval[NO_SHADER]) {
Shader *shader = get_shader("bullet_color");
glUseProgram(shader->prog);
glUniform4fv(uniloc(shader, "color"), 1, (GLfloat *)proj->clr);
}
if(proj->clr != NULL && tconfig.intval[NO_SHADER])
glColor3f(0,0,0);
draw_texture_p(0,0, proj->tex);
if(proj->clr != NULL && tconfig.intval[NO_SHADER])
glColor3f(1,1,1);
if(!tconfig.intval[NO_SHADER])
glUseProgram(0);
}
bool ShaderMaterial::_get(const StringName& p_name,Variant &r_ret) const {
if (p_name==SceneStringNames::get_singleton()->shader_shader) {
r_ret=get_shader();
return true;
} else {
String n = p_name;
if (n.begins_with("param/")) {
r_ret=VisualServer::get_singleton()->material_get_param(material,String(n.ptr()+6));
return true;
}
}
return false;
}
void stage4_fog(int fbonum) {
Shader *shader = get_shader("zbuf_fog");
float f = 0;
if(global.timer > 5100) {
float v = (global.timer-5100)*0.0005;
f = v < 0.1 ? v : 0.1;
}
glUseProgram(shader->prog);
glUniform1i(uniloc(shader, "depth"),2);
glUniform4f(uniloc(shader, "fog_color"),10*f,0,0.1-f,1.0);
glUniform1f(uniloc(shader, "start"),0.4);
glUniform1f(uniloc(shader, "end"),0.8);
glUniform1f(uniloc(shader, "exponent"),4.0);
glActiveTexture(GL_TEXTURE0 + 2);
glBindTexture(GL_TEXTURE_2D, resources.fbg[fbonum].depth);
glActiveTexture(GL_TEXTURE0);
draw_fbo_viewport(&resources.fbg[fbonum]);
glUseProgram(0);
}
NE_API void set_shader(asset_handle handle) {
bind_shader_program(get_shader(handle));
}
static void set_color_uniform(vector4f Color) {
shader_asset* shader = get_shader(current_shader_asset);
set_uniform_vector4f(shader->color_uniform, Color);
}
unsigned int get_geometry_shader(const char *fname)
{
return get_shader(fname, GL_GEOMETRY_SHADER);
}
unsigned int get_tesseval_shader(const char *fname)
{
return get_shader(fname, GL_TESS_EVALUATION_SHADER);
}
unsigned int get_tessctl_shader(const char *fname)
{
return get_shader(fname, GL_TESS_CONTROL_SHADER);
}
unsigned int get_pixel_shader(const char *fname)
{
return get_shader(fname, GL_FRAGMENT_SHADER);
}
NE_API void set_model_matrix(transform3f* transform) {
set_uniform_matrix4(get_shader(current_shader_asset)->model_uniform, to_glm_mat4(transform));
}
ColorPicker::ColorPicker() :
BoxContainer(true) {
updating=true;
edit_alpha=true;
text_is_constructor = false;
raw_mode_enabled=false;
changing_color=false;
screen=NULL;
HBoxContainer *hb_smpl = memnew( HBoxContainer );
btn_pick = memnew( ToolButton );
btn_pick->connect("pressed",this,"_screen_pick_pressed");
sample = memnew( TextureFrame );
sample->set_h_size_flags(SIZE_EXPAND_FILL);
sample->connect("draw",this,"_sample_draw");
hb_smpl->add_child(sample);
hb_smpl->add_child(btn_pick);
add_child(hb_smpl);
HBoxContainer *hb_edit = memnew( HBoxContainer );
uv_edit= memnew ( TextureFrame );
Image i(256, 256, false, Image::FORMAT_RGB);
for (int y=0;y<256;y++)
for (int x=0;x<256;x++)
i.put_pixel(x,y,Color());
Ref<ImageTexture> t;
t.instance();
t->create_from_image(i);
uv_edit->set_texture(t);
uv_edit->set_ignore_mouse(false);
uv_edit->set_custom_minimum_size(Size2(256,256));
uv_edit->connect("input_event", this, "_uv_input");
Control *c= memnew( Control );
uv_edit->add_child(c);
c->set_area_as_parent_rect();
c->set_stop_mouse(false);
c->set_material(memnew ( CanvasItemMaterial ));
Vector<Variant> args=Vector<Variant>();
args.push_back(0);
args.push_back(c);
c->connect("draw",this,"_hsv_draw",args);
add_child(hb_edit);
w_edit= memnew( TextureFrame );
i = Image(15, 256, false, Image::FORMAT_RGB);
for (int y=0;y<256;y++)
for (int x=0;x<15;x++)
i.put_pixel(x,y,Color());
Ref<ImageTexture> tw;
tw.instance();
tw->create_from_image(i);
w_edit->set_texture(tw);
w_edit->set_ignore_mouse(false);
w_edit->set_custom_minimum_size(Size2(15,256));
w_edit->connect("input_event", this, "_w_input");
c= memnew( Control );
w_edit->add_child(c);
c->set_area_as_parent_rect();
c->set_stop_mouse(false);
c->set_material(memnew ( CanvasItemMaterial ));
args.clear();
args.push_back(1);
args.push_back(c);
c->connect("draw",this,"_hsv_draw",args);
hb_edit->add_child(uv_edit);
hb_edit->add_child(memnew( VSeparator ));
hb_edit->add_child(w_edit);
VBoxContainer *vbl = memnew( VBoxContainer );
add_child(vbl);
add_child(memnew( HSeparator ));
VBoxContainer *vbr = memnew( VBoxContainer );
add_child(vbr);
vbr->set_h_size_flags(SIZE_EXPAND_FILL);
const char* lt[4] = {"R","G","B","A"};
for(int i=0;i<4;i++) {
HBoxContainer *hbc = memnew( HBoxContainer );
labels[i]=memnew( Label(lt[i]) );
hbc->add_child(labels[i]);
scroll[i]=memnew( HSlider );
hbc->add_child(scroll[i]);
values[i]=memnew( SpinBox );
scroll[i]->share(values[i]);
hbc->add_child(values[i]);
scroll[i]->set_min(0);
scroll[i]->set_page(0);
scroll[i]->set_h_size_flags(SIZE_EXPAND_FILL);
scroll[i]->connect("value_changed",this,"_value_changed");
vbr->add_child(hbc);
}
HBoxContainer *hhb = memnew( HBoxContainer );
btn_mode = memnew( CheckButton );
btn_mode->set_text("RAW Mode");
btn_mode->connect("toggled", this, "set_raw_mode");
hhb->add_child(btn_mode);
vbr->add_child(hhb);
text_type = memnew( Button );
text_type->set_flat(true);
text_type->connect("pressed", this, "_text_type_toggled");
hhb->add_child(text_type);
c_text = memnew( LineEdit );
hhb->add_child(c_text);
c_text->connect("text_entered",this,"_html_entered");
text_type->set_text("#");
c_text->set_h_size_flags(SIZE_EXPAND_FILL);
_update_controls();
//_update_color();
updating=false;
uv_material.instance();
Ref<Shader> s_uv = get_shader("uv_editor");
uv_material->set_shader(s_uv);
w_material.instance();
Ref<Shader> s_w = get_shader("w_editor");
w_material->set_shader(s_w);
uv_edit->set_material(uv_material);
w_edit->set_material(w_material);
set_color(Color(1,1,1));
i.create(256,20,false,Image::FORMAT_RGB);
for (int y=0;y<20;y++)
for(int x=0;x<256;x++)
if ((x/4+y/4)%2)
i.put_pixel(x,y,Color(1,1,1));
else
i.put_pixel(x,y,Color(0.6,0.6,0.6));
Ref<ImageTexture> t_smpl;
t_smpl.instance();
t_smpl->create_from_image(i);
sample->set_texture(t_smpl);
HBoxContainer *bbc = memnew( HBoxContainer );
add_child(bbc);
preset = memnew( TextureFrame );
bbc->add_child(preset);
preset->set_ignore_mouse(false);
preset->connect("input_event", this, "_preset_input");
bt_add_preset = memnew ( Button );
bt_add_preset->set_icon(get_icon("add_preset"));
bt_add_preset->set_tooltip("Add current color as a preset");
bt_add_preset->connect("pressed", this, "_add_preset_pressed");
bbc->add_child(bt_add_preset);
}
NE_API void set_model_matrix(const glm::mat4& matrix) {
set_uniform_matrix4(get_shader(current_shader_asset)->model_uniform, matrix);
}
unsigned int get_vertex_shader(const char *fname)
{
return get_shader(fname, GL_VERTEX_SHADER);
}
