void ColorSpace::set_mouse_pos(const QPoint & p)
{
float s = float(p.x()) / float(width());
float v = 1.0f - float(p.y()) / float(height());
set_hsv(hue, s, v);
((PaletteEditor*)parentWidget())->set_palette();
}
void light_system::render_all_lights(augs::renderer& output, const std::array<float, 16> projection_matrix, const viewing_step step, std::function<void()> neon_callback) {
const auto& cosmos = step.cosm;
const auto dt = step.get_delta();
const float global_time_seconds = static_cast<float>(step.get_interpolated_total_time_passed_in_seconds());
ensure_eq(0, output.get_triangle_count());
output.light_fbo.use();
glClearColor(0.1f, 0.2f, 0.2f, 1.0f);
output.clear_current_fbo();
glClearColor(0.f, 0.f, 0.f, 0.f);
auto& light_program = *get_resource_manager().find(assets::program_id::LIGHT);
auto& default_program = *get_resource_manager().find(assets::program_id::DEFAULT);
light_program.use();
const auto light_pos_uniform = glGetUniformLocation(light_program.id, "light_pos");
const auto light_max_distance_uniform = glGetUniformLocation(light_program.id, "max_distance");
const auto light_attenuation_uniform = glGetUniformLocation(light_program.id, "light_attenuation");
const auto light_multiply_color_uniform = glGetUniformLocation(light_program.id, "multiply_color");
const auto projection_matrix_uniform = glGetUniformLocation(light_program.id, "projection_matrix");
const auto& interp = step.session.systems_audiovisual.get<interpolation_system>();
const auto& particles = step.session.systems_audiovisual.get<particles_simulation_system>();
const auto& visible_per_layer = step.visible.per_layer;
std::vector<messages::visibility_information_request> requests;
std::vector<messages::visibility_information_response> responses;
glUniformMatrix4fv(projection_matrix_uniform, 1, GL_FALSE, projection_matrix.data());
for (const auto it : cosmos.get(processing_subjects::WITH_LIGHT)) {
messages::visibility_information_request request;
request.eye_transform = it.viewing_transform(interp);
request.filter = filters::line_of_sight_query();
request.square_side = it.get<components::light>().max_distance.base_value;
request.subject = it;
requests.push_back(request);
}
{
std::vector<messages::line_of_sight_response> dummy;
visibility_system().respond_to_visibility_information_requests(cosmos, {}, requests, dummy, responses);
}
const auto camera_transform = step.camera.transform;
const auto camera_size = step.camera.visible_world_area;
const auto camera_offset = -camera_transform.pos + camera_size / 2;
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE, GL_ONE); glerr;
for (size_t i = 0; i < responses.size(); ++i) {
const auto& r = responses[i];
const auto& light_entity = cosmos[requests[i].subject];
const auto& light = light_entity.get<components::light>();
auto& cache = per_entity_cache[light_entity.get_id().pool.indirection_index];
const float delta = dt.in_seconds();
light.constant.variation.update_value(rng, cache.all_variation_values[0], delta);
light.linear.variation.update_value(rng, cache.all_variation_values[1], delta);
light.quadratic.variation.update_value(rng, cache.all_variation_values[2], delta);
light.wall_constant.variation.update_value(rng, cache.all_variation_values[3], delta);
light.wall_linear.variation.update_value(rng, cache.all_variation_values[4], delta);
light.wall_quadratic.variation.update_value(rng, cache.all_variation_values[5], delta);
light.position_variations[0].update_value(rng, cache.all_variation_values[6], delta);
light.position_variations[1].update_value(rng, cache.all_variation_values[7], delta);
for (size_t t = 0; t < r.get_num_triangles(); ++t) {
const auto world_light_tri = r.get_world_triangle(t, requests[i].eye_transform.pos);
augs::vertex_triangle renderable_light_tri;
renderable_light_tri.vertices[0].pos = world_light_tri.points[0] + camera_offset;
renderable_light_tri.vertices[1].pos = world_light_tri.points[1] + camera_offset;
renderable_light_tri.vertices[2].pos = world_light_tri.points[2] + camera_offset;
auto considered_color = light.color;
if (considered_color == black) {
considered_color.set_hsv({ fmod(global_time_seconds / 16.f, 1.f), 1.0, 1.0 });
}
renderable_light_tri.vertices[0].color = considered_color;
renderable_light_tri.vertices[1].color = considered_color;
renderable_light_tri.vertices[2].color = considered_color;
output.push_triangle(renderable_light_tri);
}
//for (size_t d = 0; d < r.get_num_discontinuities(); ++d) {
// const auto world_discontinuity = *r.get_discontinuity(d);
//
// if (!world_discontinuity.is_boundary) {
// vertex_triangle renderable_light_tri;
//
// const float distance_from_light = (requests[i].eye_transform.pos - world_discontinuity.points.first).length();
// const float angle = 80.f / ((distance_from_light+0.1f)/50.f);
//
// //(requests[i].eye_transform.pos - world_discontinuity.points.first).length();
//
// if (world_discontinuity.winding == world_discontinuity.RIGHT) {
// renderable_light_tri.vertices[0].pos = world_discontinuity.points.first + camera_offset;
// renderable_light_tri.vertices[1].pos = world_discontinuity.points.second + camera_offset;
// renderable_light_tri.vertices[2].pos = vec2(world_discontinuity.points.second).rotate(-angle, world_discontinuity.points.first) + camera_offset;
// }
// else {
// renderable_light_tri.vertices[0].pos = world_discontinuity.points.first + camera_offset;
// renderable_light_tri.vertices[1].pos = world_discontinuity.points.second + camera_offset;
// renderable_light_tri.vertices[2].pos = vec2(world_discontinuity.points.second).rotate(angle, world_discontinuity.points.first) + camera_offset;
// }
//
// renderable_light_tri.vertices[0].color = light.color;
// renderable_light_tri.vertices[1].color = light.color;
// renderable_light_tri.vertices[2].color = light.color;
//
// output.push_triangle(renderable_light_tri);
// }
//}
vec2 light_displacement = vec2(cache.all_variation_values[6], cache.all_variation_values[7]);
auto screen_pos = requests[i].eye_transform - camera_transform;
screen_pos.pos.x += camera_size.x * 0.5f;
screen_pos.pos.y = camera_size.y - (screen_pos.pos.y + camera_size.y * 0.5f);
screen_pos += light_displacement;
glUniform2f(light_pos_uniform, screen_pos.pos.x, screen_pos.pos.y);
glUniform1f(light_max_distance_uniform, light.max_distance.base_value);
glUniform3f(light_attenuation_uniform,
cache.all_variation_values[0] + light.constant.base_value,
cache.all_variation_values[1] + light.linear.base_value,
cache.all_variation_values[2] + light.quadratic.base_value
);
glUniform3f(light_multiply_color_uniform,
1.f,
1.f,
1.f);
output.call_triangles();
output.clear_triangles();
light_program.use();
glUniform1f(light_max_distance_uniform, light.wall_max_distance.base_value);
glUniform3f(light_attenuation_uniform,
cache.all_variation_values[3] + light.wall_constant.base_value,
cache.all_variation_values[4] + light.wall_linear.base_value,
cache.all_variation_values[5] + light.wall_quadratic.base_value
);
glUniform3f(light_multiply_color_uniform,
light.color.r/255.f,
light.color.g/255.f,
light.color.b/255.f);
render_system().draw_entities(interp, global_time_seconds,output.triangles, visible_per_layer[render_layer::DYNAMIC_BODY], step.camera, renderable_drawing_type::NORMAL);
output.call_triangles();
output.clear_triangles();
glUniform3f(light_multiply_color_uniform,
1.f,
1.f,
1.f);
}
default_program.use();
render_system().draw_entities(interp, global_time_seconds,output.triangles, visible_per_layer[render_layer::DYNAMIC_BODY], step.camera, renderable_drawing_type::NEON_MAPS);
render_system().draw_entities(interp, global_time_seconds,output.triangles, visible_per_layer[render_layer::SMALL_DYNAMIC_BODY], step.camera, renderable_drawing_type::NEON_MAPS);
render_system().draw_entities(interp, global_time_seconds,output.triangles, visible_per_layer[render_layer::FLYING_BULLETS], step.camera, renderable_drawing_type::NEON_MAPS);
render_system().draw_entities(interp, global_time_seconds,output.triangles, visible_per_layer[render_layer::CAR_INTERIOR], step.camera, renderable_drawing_type::NEON_MAPS);
render_system().draw_entities(interp, global_time_seconds,output.triangles, visible_per_layer[render_layer::CAR_WHEEL], step.camera, renderable_drawing_type::NEON_MAPS);
render_system().draw_entities(interp, global_time_seconds,output.triangles, visible_per_layer[render_layer::EFFECTS], step.camera, renderable_drawing_type::NEON_MAPS);
render_system().draw_entities(interp, global_time_seconds,output.triangles, visible_per_layer[render_layer::ON_GROUND], step.camera, renderable_drawing_type::NEON_MAPS);
render_system().draw_entities(interp, global_time_seconds,output.triangles, visible_per_layer[render_layer::ON_TILED_FLOOR], step.camera, renderable_drawing_type::NEON_MAPS);
{
particles_simulation_system::drawing_input in(output.triangles);
in.camera = step.camera;
in.drawing_type = renderable_drawing_type::NEON_MAPS;
particles.draw(render_layer::EFFECTS, in);
}
neon_callback();
output.call_triangles();
output.clear_triangles();
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE); glerr;
augs::graphics::fbo::use_default();
output.set_active_texture(2);
output.bind_texture(output.light_fbo);
output.set_active_texture(0);
}
void Color3f::v(float value) {
set_hsv(h(), s(), gua::math::clamp(value, 0.0f, 1.0f));
}
void Color3f::s(float saturation) {
set_hsv(h(), gua::math::clamp(saturation, 0.0f, 1.0f), v());
}
void Color3f::h(float hue) { set_hsv(hue, s(), v()); }
void program_step(void) {
struct rgb_colour colour_rgb;
struct hsv_colour colour_hsv;
uint16_t param = 0;
switch((enum program_opcode) read_byte()) {
case OP_HALT:
instruction--;
return;
case OP_SET_RGB:
colour_rgb.red = read_byte();
colour_rgb.green = read_byte();
colour_rgb.blue = read_byte();
set_rgb(colour_rgb);
// immediatly execute next step - since
program_step();
break;
case OP_SET_HSV:
colour_hsv.hue = read_byte();
colour_hsv.saturation = read_byte();
colour_hsv.value = read_byte();
set_hsv(colour_hsv);
// immediatly execute next step - since
program_step();
break;
case OP_FADE_RGB:
colour_rgb.red = read_byte();
colour_rgb.green = read_byte();
colour_rgb.blue = read_byte();
// Duration
param |= (read_byte() << 8) | read_byte();
fade_rgb(colour_rgb, param);
break;
case OP_FADE_HSV:
colour_hsv.hue = read_byte();
colour_hsv.saturation = read_byte();
colour_hsv.value = read_byte();
// Duration
param |= (read_byte() << 8) | read_byte();
fade_hsv(colour_hsv, param);
break;
case OP_WAIT:
// Duration
param |= (read_byte() << 8) | read_byte();
wait(param);
break;
case OP_GOTO_ROM:
// Target offset
param |= (read_byte() << 8) | read_byte();
current_addrspace = ADDR_ROM;
instruction = rom + param;
program_step();
break;
case OP_GOTO:
// Target offset
param |= (read_byte() << 8) | read_byte();
if(current_addrspace == ADDR_ROM) {
instruction = rom + param;
} else {
instruction = ram_base + param;
}
program_step();
break;
case OP_WRITE_ROM:
// read offset at which to store new values
param |= (read_byte() << 8) | read_byte();
uint8_t *write_pos = rom + param;
// Write n bytes
for(param = read_byte(); param > 0; param--) {
if(write_pos < rom || write_pos >= (rom + rom_size))
break;
eeprom_write_byte(write_pos++, read_byte());
}
program_step();
break;
default:
break;
}
}
void ColorSpace::set_hue(float h)
{
set_hsv(h, sat, val);
}
ColorSpace::ColorSpace(QWidget * parent)
: QWidget(parent), pix(NULL), hue(-1.0f)
{
set_hsv(0.5f, 0.5f, 0.5f);
}
void program_step(void) {
struct rgb_colour colour_rgb;
struct hsv_colour colour_hsv;
uint16_t duration = 0;
switch((enum program_opcode) read_byte()) {
case OP_HALT:
instruction--;
return;
case OP_SET_RGB:
colour_rgb.red = read_byte();
colour_rgb.green = read_byte();
colour_rgb.blue = read_byte();
set_rgb(colour_rgb);
// immediatly execute next step - since
program_step();
break;
case OP_SET_HSV:
colour_hsv.hue = read_byte();
colour_hsv.saturation = read_byte();
colour_hsv.value = read_byte();
set_hsv(colour_hsv);
// immediatly execute next step - since
program_step();
break;
case OP_FADE_RGB:
colour_rgb.red = read_byte();
colour_rgb.green = read_byte();
colour_rgb.blue = read_byte();
duration |= (read_byte() << 8) | read_byte();
fade_rgb(colour_rgb, duration);
break;
case OP_FADE_HSV:
colour_hsv.hue = read_byte();
colour_hsv.saturation = read_byte();
colour_hsv.value = read_byte();
duration |= (read_byte() << 8) | read_byte();
fade_hsv(colour_hsv, duration);
break;
case OP_WAIT:
duration |= (read_byte() << 8) | read_byte();
wait(duration);
break;
case OP_GOTO_ROM:
current_addrspace = ADDR_ROM;
case OP_GOTO:
duration |= (read_byte() << 8) | read_byte();
if(current_addrspace == ADDR_ROM) {
instruction = rom + duration;
} else {
instruction = ram_base + duration;
}
program_step();
break;
default:
break;
}
}
