Texture2D::Texture2D(GraphicContext &context, int width, int height, TextureFormat texture_format, int levels)
: Texture(std::shared_ptr<Texture_Impl>(new Texture_Impl))
{
if ( (width<=0) || (height<=0) )
{
throw Exception("An attempt was made to create a Texture with an invalid size");
}
GraphicContextProvider *gc_provider = context.get_provider();
impl->provider = gc_provider->alloc_texture(texture_2d);
impl->provider->create(width, height, 1, 1, texture_format, levels);
impl->width = width;
impl->height = height;
impl->provider->set_wrap_mode(impl->wrap_mode_s, impl->wrap_mode_t);
}
PixelBuffer D3DTextureProvider::get_pixeldata(GraphicContext &gc, TextureFormat texture_format, int level) const
{
D3DGraphicContextProvider *gc_provider = static_cast<D3DGraphicContextProvider*>(gc.get_provider());
D3DTextureData::DeviceHandles &data_handles = data->get_handles(gc_provider->get_window()->get_device());
int width;
int height;
DXGI_FORMAT format;
if (data_handles.texture_type == D3DTextureData::cl_ID3D11Texture1D)
{
D3D11_TEXTURE1D_DESC texture_desc;
data_handles.get_texture_1d()->GetDesc(&texture_desc);
width = max(texture_desc.Width >> level, (UINT)1);
height = 1;
format = texture_desc.Format;
}
Texture3D::Texture3D(GraphicContext &context, const Vec3i &size, TextureFormat texture_format, int levels)
: Texture(std::shared_ptr<Texture_Impl>(new Texture_Impl))
{
if ( (size.x<=0) || (size.y<=0) || (size.z<=0) )
{
throw Exception("An attempt was made to create a Texture with an invalid size");
}
GraphicContextProvider *gc_provider = context.get_provider();
impl->provider = gc_provider->alloc_texture(texture_3d);
impl->provider->create(size.x, size.y, size.z, 1, texture_format, levels);
impl->width = size.x;
impl->height = size.y;
impl->depth = size.z;
impl->provider->set_wrap_mode(impl->wrap_mode_s, impl->wrap_mode_t, impl->wrap_mode_r);
}
void App::render(GraphicContext &gc)
{
gc.clear(Colorf(0.0f, 0.0f, 0.0f, 1.0f));
Rect viewport_rect(0, 0, Size(gc.get_width(), gc.get_height()));
gc.set_viewport(viewport_rect);
gc.clear_depth(1.0f);
Mat4f modelview_matrix = scene.gs->camera_modelview;
scene.Draw(modelview_matrix, gc);
gc.reset_program_object();
}
void D3DVertexArrayBufferProvider::upload_data(GraphicContext &gc, int offset, const void *data, int data_size)
{
if ((offset < 0) || (data_size < 0) || ((data_size + offset) > size))
throw Exception("Vertex array buffer, invalid size");
const ComPtr<ID3D11Device> &device = static_cast<D3DGraphicContextProvider*>(gc.get_provider())->get_window()->get_device();
ComPtr<ID3D11DeviceContext> device_context;
device->GetImmediateContext(device_context.output_variable());
D3D11_BOX box;
box.left = offset;
box.right = offset + data_size;
box.top = 0;
box.bottom = 1;
box.front = 0;
box.back = 1;
device_context->UpdateSubresource(get_handles(device).buffer, 0, &box, data, 0, 0);
}
BloomPass::BloomPass(GraphicContext &gc, const std::string &shader_path, ResourceContainer &inout)
{
viewport = inout.get<Rect>("Viewport");
final_color = inout.get<Texture2D>("FinalColor");
bloom_contribution = inout.get<Texture2D>("BloomContribution");
if (gc.get_shader_language() == shader_glsl)
{
bloom_shader = ShaderSetup::compile(gc, "", PathHelp::combine(shader_path, "Final/vertex_present.glsl"), PathHelp::combine(shader_path, "Bloom/fragment_bloom_extract.glsl"), "");
bloom_shader.bind_frag_data_location(0, "FragColor");
}
else
{
bloom_shader = ShaderSetup::compile(gc, "", PathHelp::combine(shader_path, "Final/vertex_present.hlsl"), PathHelp::combine(shader_path, "Bloom/fragment_bloom_extract.hlsl"), "");
}
ShaderSetup::link(bloom_shader, "bloom extract program");
bloom_shader.bind_attribute_location(0, "PositionInProjection");
bloom_shader.set_uniform1i("FinalColors", 0);
bloom_shader.set_uniform1i("FinalColorsSampler", 0);
bloom_shader.set_uniform1i("LogAverageLight", 1);
Vec4f positions[6] =
{
Vec4f(-1.0f, -1.0f, 1.0f, 1.0f),
Vec4f( 1.0f, -1.0f, 1.0f, 1.0f),
Vec4f(-1.0f, 1.0f, 1.0f, 1.0f),
Vec4f( 1.0f, -1.0f, 1.0f, 1.0f),
Vec4f(-1.0f, 1.0f, 1.0f, 1.0f),
Vec4f( 1.0f, 1.0f, 1.0f, 1.0f)
};
rect_positions = VertexArrayVector<Vec4f>(gc, positions, 6);
rect_primarray = PrimitivesArray(gc);
rect_primarray.set_attributes(0, rect_positions);
bloom_blur.input = bloom_contribution;
BlendStateDescription blend_desc;
blend_desc.enable_blending(false);
blend_state = BlendState(gc, blend_desc);
}
Shader::Shader(GraphicContext &gc)
{
ShaderLanguage shader_language = gc.get_shader_language();
ShaderObject vertex_shader(gc, shadertype_vertex, shader_language==shader_glsl ? vertex_glsl : vertex_hlsl);
if(!vertex_shader.compile())
{
std::string log = vertex_shader.get_info_log();
throw Exception(string_format("Unable to compile vertex shader object: %1", log));
}
ShaderObject fragment_shader(gc, shadertype_fragment, shader_language==shader_glsl ? fragment_glsl : fragment_hlsl);
if(!fragment_shader.compile())
{
std::string log = fragment_shader.get_info_log();
throw Exception(string_format("Unable to compile fragment shader object: %1", log));
}
program_object = ProgramObject(gc);
program_object.attach(vertex_shader);
program_object.attach(fragment_shader);
program_object.bind_attribute_location(0, "InPosition");
program_object.bind_attribute_location(1, "InNormal");
program_object.bind_attribute_location(2, "InMaterialAmbient");
program_object.bind_frag_data_location(0, "cl_FragColor");
if (!program_object.link())
{
throw Exception(string_format("Unable to link program object: %1", program_object.get_info_log()));
}
program_object.set_uniform_buffer_index("ProgramUniforms", 0);
gpu_uniforms = clan::UniformVector<ProgramUniforms>(gc, 1);
uniforms.LightAmbient = Vec4f(0.2f, 0.2f, 0.2f, 1.0f);
uniforms.LightVector = Vec3f(0.0f, 0.0f, -1.0f);
uniforms.LightDiffuse = Vec4f(0.7f, 0.7f, 0.7f, 1.0f);
}
void D3DStorageBufferProvider::copy_to(GraphicContext &gc, TransferBuffer &buffer, int dest_pos, int src_pos, int copy_size)
{
const ComPtr<ID3D11Device> &device = static_cast<D3DGraphicContextProvider*>(gc.get_provider())->get_window()->get_device();
ComPtr<ID3D11Buffer> &transfer_buffer = static_cast<D3DTransferBufferProvider*>(buffer.get_provider())->get_buffer(device);
int transfer_buffer_size = static_cast<D3DTransferBufferProvider*>(buffer.get_provider())->get_size();
if (copy_size == -1)
copy_size = transfer_buffer_size;
if (dest_pos < 0 || copy_size < 0 || dest_pos + copy_size > transfer_buffer_size || src_pos < 0 || src_pos + copy_size > size)
throw Exception("Out of bounds!");
ComPtr<ID3D11DeviceContext> device_context;
device->GetImmediateContext(device_context.output_variable());
D3D11_BOX box;
box.left = dest_pos;
box.right = dest_pos + copy_size;
box.top = 0;
box.bottom = 1;
box.front = 0;
box.back = 1;
device_context->CopySubresourceRegion(transfer_buffer, 0, src_pos, 0, 0, get_handles(device).buffer, 0, &box);
}
void ParticleEmitterPass::run(GraphicContext &gc, Scene_Impl *scene)
{
setup(gc);
Size viewport_size = viewport->get_size();
Mat4f eye_to_projection = Mat4f::perspective(field_of_view.get(), viewport_size.width/(float)viewport_size.height, 0.1f, 1.e10f, handed_left, gc.get_clip_z_range());
Mat4f eye_to_cull_projection = Mat4f::perspective(field_of_view.get(), viewport_size.width/(float)viewport_size.height, 0.1f, 150.0f, handed_left, clip_negative_positive_w);
FrustumPlanes frustum(eye_to_cull_projection * world_to_eye.get());
for (size_t i = 0; i < active_emitters.size(); i++)
active_emitters[i]->visible = false;
scene->visit_emitters(gc, world_to_eye.get(), eye_to_projection, frustum, this);
const int vectors_per_particle = 2;
size_t total_particle_count = 0;
for (size_t i = 0; i < active_emitters.size(); i++)
{
float depth_fade_distance = 1.0f;
ParticleUniforms uniforms;
uniforms.eye_to_projection = eye_to_projection;
uniforms.object_to_eye = world_to_eye.get();
uniforms.rcp_depth_fade_distance = 1.0f / depth_fade_distance;
uniforms.instance_vectors_offset = total_particle_count * vectors_per_particle;
active_emitters[i]->gpu_uniforms.upload_data(gc, &uniforms, 1);
total_particle_count += active_emitters[i]->cpu_particles.size();
}
if (total_particle_count == 0)
return;
if (instance_texture.is_null() || instance_texture.get_width() < (int)total_particle_count)
{
instance_texture = Texture2D(gc, total_particle_count * vectors_per_particle, 1, tf_rgba32f);
instance_transfer = TransferTexture(gc, total_particle_count * vectors_per_particle, 1, data_to_gpu, tf_rgba32f, 0, usage_stream_draw);
}
instance_transfer.lock(gc, access_write_discard);
Vec4f *vectors = instance_transfer.get_data<Vec4f>();
size_t vector_offset = 0;
for (size_t j = 0; j < active_emitters.size(); j++)
{
Vec3f eye_pos = scene->get_camera().get_position();
std::vector<ParticleOrderIndex> sorted_particles;
sorted_particles.reserve(active_emitters[j]->cpu_particles.size());
for (size_t i = 0; i < active_emitters[j]->cpu_particles.size(); i++)
{
Vec3f delta = active_emitters[j]->cpu_particles[i].position - eye_pos;
sorted_particles.push_back(ParticleOrderIndex(i, Vec3f::dot(delta, delta)));
}
std::sort(sorted_particles.begin(), sorted_particles.end());
for (size_t k = 0; k < sorted_particles.size(); k++)
{
int i = sorted_particles[k].index;
float size = mix(active_emitters[j]->cpu_particles[i].start_size, active_emitters[j]->cpu_particles[i].end_size, active_emitters[j]->cpu_particles[i].life);
vectors[vector_offset + k * vectors_per_particle + 0] = Vec4f(active_emitters[j]->cpu_particles[i].position, size);
vectors[vector_offset + k * vectors_per_particle + 1] = Vec4f(active_emitters[j]->cpu_particles[i].life, 0.0f, 0.0f, 0.0f);
}
vector_offset += active_emitters[j]->cpu_particles.size() * vectors_per_particle;
}
instance_transfer.unlock();
instance_texture.set_image(gc, instance_transfer);
gc.set_depth_range(0.0f, 0.9f);
gc.set_frame_buffer(fb);
gc.set_viewport(viewport_size);
gc.set_depth_stencil_state(depth_stencil_state);
gc.set_blend_state(blend_state);
gc.set_rasterizer_state(rasterizer_state);
gc.set_primitives_array(prim_array);
gc.set_program_object(program);
gc.set_texture(0, normal_z_gbuffer.get());
gc.set_texture(1, instance_texture);
for (size_t i = 0; i < active_emitters.size(); i++)
{
gc.set_uniform_buffer(0, active_emitters[i]->gpu_uniforms);
gc.set_texture(2, active_emitters[i]->particle_animation.get());
gc.set_texture(3, active_emitters[i]->life_color_gradient.get());
gc.draw_primitives_array_instanced(type_triangles, 0, 6, active_emitters[i]->cpu_particles.size());
}
gc.reset_primitives_array();
gc.reset_rasterizer_state();
gc.reset_depth_stencil_state();
gc.reset_program_object();
gc.reset_primitives_elements();
gc.reset_texture(0);
gc.reset_texture(1);
gc.reset_texture(2);
gc.reset_texture(3);
gc.reset_uniform_buffer(0);
gc.reset_frame_buffer();
gc.set_depth_range(0.0f, 1.0f);
}
void LightsourceSimplePass::find_lights(GraphicContext &gc, Scene_Impl *scene)
{
lights.clear();
Size viewport_size = viewport->get_size();
Mat4f eye_to_projection = Mat4f::perspective(field_of_view.get(), viewport_size.width/(float)viewport_size.height, 0.1f, 1.e10f, handed_left, gc.get_clip_z_range());
Mat4f eye_to_cull_projection = Mat4f::perspective(field_of_view.get(), viewport_size.width/(float)viewport_size.height, 0.1f, 150.0f, handed_left, clip_negative_positive_w);
FrustumPlanes frustum(eye_to_cull_projection * world_to_eye.get());
scene->visit_lights(gc, world_to_eye.get(), eye_to_projection, frustum, this);
}
void Texture2D::copy_subimage_from(GraphicContext &context, int offset_x, int offset_y, int x, int y, int width, int height, int level)
{
impl->provider->copy_subimage_from(offset_x, offset_y, x, y, width, height, level, context.get_provider());
}
void Texture2D::copy_subimage_from(GraphicContext &context, const Point &offset, const Rect &pos, int level)
{
impl->provider->copy_subimage_from(offset.x, offset.y, pos.left, pos.top, pos.get_width(), pos.get_height(), level, context.get_provider());
}
BlendState::BlendState(GraphicContext &context, const BlendStateDescription &desc)
: provider(context.get_provider()->create_blend_state(desc))
{
}
virtual int main(const std::vector<std::string> &args)
{
DisplayWindowDescription desc;
desc.set_size(Size(800,600), true);
desc.set_title("Span Layout Test");
DisplayWindow window(desc);
Canvas canvas(window);
GraphicContext gc = window.get_gc();
FontDescription font_desc1;
font_desc1.set_typeface_name("Verdana");
font_desc1.set_height(-13);
Font font1(canvas, font_desc1);
Image smiley(canvas, "smiley.png");
SpanLayout span;
span.add_text(" This is a ", font1, Colorf::white, 1);
span.add_text("red", font1, Colorf::red, 2);
span.add_text(" text! ", font1, Colorf::white, 3);
span.add_text("And this complete text is green with non-blocking space..", font1, Colorf::green, 4);
span.add_image(smiley, 10, 5);
span.add_text("This is a really long descriptive and interesting text. ", font1, Colorf::yellow, 6);
span.add_text("[", font1, Colorf::black, 7);
span.add_text("15:35", font1, Colorf::white, 8);
span.add_text("]", font1, Colorf::black, 9);
span.add_image(smiley, 0, 10);
span.add_image(smiley, 2, 11);
span.add_text("kthxbye!", font1, Colorf::blue, 12);
span.layout(gc, 200);
span.set_position(Point(10, 10));
while (!window.get_ic().get_keyboard().get_keycode(keycode_escape))
{
gc.clear(Colorf::gray70);
span.draw_layout(canvas);
Point mouse_pos = window.get_ic().get_mouse().get_position();
SpanLayout::HitTestResult result = span.hit_test(gc, mouse_pos);
std::string type;
switch(result.type)
{
case SpanLayout::HitTestResult::no_objects_available:
type = "no_objects_available";
break;
case SpanLayout::HitTestResult::outside_top:
type = "outside_top";
break;
case SpanLayout::HitTestResult::outside_left:
type = "outside_left";
break;
case SpanLayout::HitTestResult::outside_right:
type = "outside_right";
break;
case SpanLayout::HitTestResult::outside_bottom:
type = "outside_bottom";
break;
case SpanLayout::HitTestResult::inside:
type = "inside";
break;
}
std::string result_text = string_format("HitTestResult: Type:%1 ID:%2 Offset:%3", type, result.object_id, result.offset);
font1.draw_text(canvas, 10, 300, result_text);
window.flip();
KeepAlive::process();
System::sleep(50);
}
return 0;
}
void ShaderEffect::dispatch(GraphicContext &gc, int x, int y, int z)
{
gc.set_program_object(impl->program);
for (auto & elem : impl->uniform_bindings)
{
gc.set_uniform_buffer(elem.first, elem.second);
}
for (auto & elem : impl->storage_bindings)
{
gc.set_storage_buffer(elem.first, elem.second);
}
for (auto & elem : impl->image_bindings)
{
gc.set_image_texture(elem.first, elem.second);
}
for (auto & elem : impl->texture_bindings)
{
gc.set_texture(elem.first, elem.second);
}
gc.dispatch(x, y, z);
for (auto & elem : impl->uniform_bindings)
{
gc.reset_uniform_buffer(elem.first);
}
for (auto & elem : impl->storage_bindings)
{
gc.reset_storage_buffer(elem.first);
}
for (auto & elem : impl->image_bindings)
{
gc.reset_image_texture(elem.first);
}
for (auto & elem : impl->texture_bindings)
{
gc.reset_texture(elem.first);
}
gc.reset_program_object();
}
ProgramObject LightsourceSimplePass::compile_and_link(GraphicContext &gc, const std::string &shader_path, const std::string &type)
{
ProgramObject program;
std::string vertex_filename = PathHelp::combine(shader_path, string_format("LightsourceSimple/vertex_%1.%2", type, gc.get_shader_language() == shader_glsl ? "glsl" : "hlsl"));
std::string fragment_filename = PathHelp::combine(shader_path, string_format("LightsourceSimple/fragment_light.%1", gc.get_shader_language() == shader_glsl ? "glsl" : "hlsl"));
program = ShaderSetup::compile(gc, "", vertex_filename, fragment_filename, type == "rect" ? "RECT_PASS" : "");
program.bind_frag_data_location(0, "FragColor");
if (!program.link())
throw Exception("Shader linking failed!");
program.bind_attribute_location(0, "AttrPositionInObject");
program.set_uniform_buffer_index("Uniforms", 0);
program.set_uniform1i("InstanceTexture", 0);
program.set_uniform1i("NormalZTexture", 1);
program.set_uniform1i("DiffuseColorTexture", 2);
program.set_uniform1i("SpecularColorTexture", 3);
program.set_uniform1i("SpecularLevelTexture", 4);
program.set_uniform1i("ShadowMapsTexture", 5);
program.set_uniform1i("ShadowMapsTextureSampler", 5);
program.set_uniform1i("SelfIlluminationTexture", 6);
return program;
}
DepthStencilState::DepthStencilState(GraphicContext &context, const DepthStencilStateDescription &desc)
: provider(context.get_provider()->create_depth_stencil_state(desc))
{
}
int Program::main(const std::vector<std::string> &args)
{
SetupCore setup_core;
SetupDisplay setup_display;
SetupD3D setup_d3d;
SetupGL setup_gl;
clan::OpenGLWindowDescription opengl_desc;
opengl_desc.set_version(3, 2, false);
clan::OpenGLTarget::set_description(opengl_desc);
DisplayWindow window("Scene3D Example", 1600, 900, false, true);
SlotContainer cc;
GraphicContext gc = window.get_gc();
bool exit = false;
cc.connect(window.sig_window_close(), [&exit]() { exit = true; });
ResourceManager resources;
SceneCache::set(resources, std::shared_ptr<SceneCache>(new ExampleSceneCache()));
std::string shader_path = "../../../Resources/Scene3D";
Scene scene(gc, resources, shader_path);
SceneCamera camera(scene);
scene.set_camera(camera);
std::vector<SceneLight> omni_lights;
for (int i = 0; i < 4; i++)
{
SceneLight omni(scene);
omni.set_type(SceneLight::type_omni);
omni.set_color(Vec3f(0.05f));
omni.set_position(Quaternionf(45.0f, 45.0f + i * 90.0f, 0.0f, angle_degrees, order_YXZ).rotate_vector(Vec3f(0.0f, 0.0f, -100.0f)));
omni.set_attenuation_end(200.0f);
omni.set_ambient_illumination(0.025f);
omni_lights.push_back(omni);
}
SceneLight spot(scene);
spot.set_type(SceneLight::type_spot);
spot.set_orientation(Quaternionf(30.0f, 30.0f, 0.0f, angle_degrees, order_YXZ));
spot.set_position(spot.get_orientation().rotate_vector(Vec3f(0.0f, 0.0f, -100.0f)));
spot.set_color(Vec3f(1.0f, 1.0f, 0.2f));
spot.set_falloff(45.0f);
spot.set_hotspot(15.0f);
spot.set_attenuation_start(20.0f);
spot.set_attenuation_end(200.0f);
spot.set_shadow_caster(true);
spot.set_rectangle_shape(false);
spot.set_aspect_ratio(1.0f);
SceneLight spot2(scene);
spot2.set_type(SceneLight::type_spot);
spot2.set_position(Vec3f(0.0f, 100.0f, 0.0f));
spot2.set_color(Vec3f(1.0f, 1.0f, 1.0f) * 3.0f);
spot2.set_falloff(35.0f);
spot2.set_hotspot(30.0f);
spot2.set_attenuation_start(20.0f);
spot2.set_attenuation_end(130.0f);
spot2.set_shadow_caster(true);
spot2.set_rectangle_shape(false);
spot2.set_ambient_illumination(0.025f);
SceneModel plane(gc, scene, "plane");
SceneModel box(gc, scene, "box");
SceneObject object(scene, plane, Vec3f(0.0f, 0.0f, 0.0f));
SceneObject box0(scene, box, Vec3f(20.0f, 5.0f, 0.0f), Quaternionf(0.0f, 20.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject box1(scene, box, Vec3f(-20.0f, 5.0f, 0.0f), Quaternionf(0.0f, 50.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject box2(scene, box, Vec3f(0.0f, 5.0f, 20.0f), Quaternionf(0.0f, 80.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject box3(scene, box, Vec3f(0.0f, 5.0f, -20.0f), Quaternionf(0.0f, 100.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject player(scene, box);
player.set_scale(Vec3f(0.25f));
Physics3DWorld physics_world;
Physics3DShape box_shape = Physics3DShape::box(Vec3f(5.0f));
Physics3DShape plane_shape = Physics3DShape::box(Vec3f(75.0f, 1.0f, 75.0f));
Physics3DShape sphere_shape = Physics3DShape::sphere(2.0f);
Physics3DObject phys_object = Physics3DObject::collision_body(physics_world, plane_shape, Vec3f(0.0f, -0.5f, 0.0f));
Physics3DObject phys_box0 = Physics3DObject::collision_body(physics_world, box_shape, Vec3f(20.0f, 5.0f, 0.0f), Quaternionf(0.0f, 20.0f, 0.0f, angle_degrees, order_YXZ));
Physics3DObject phys_box1 = Physics3DObject::collision_body(physics_world, box_shape, Vec3f(-20.0f, 5.0f, 0.0f), Quaternionf(0.0f, 50.0f, 0.0f, angle_degrees, order_YXZ));
Physics3DObject phys_box2 = Physics3DObject::collision_body(physics_world, box_shape, Vec3f(0.0f, 5.0f, 20.0f), Quaternionf(0.0f, 80.0f, 0.0f, angle_degrees, order_YXZ));
Physics3DObject phys_box3 = Physics3DObject::collision_body(physics_world, box_shape, Vec3f(0.0f, 5.0f, -20.0f), Quaternionf(0.0f, 100.0f, 0.0f, angle_degrees, order_YXZ));
Physics3DSweepTest sweep_test(physics_world);
CharacterController controller(physics_world, 1.0f, 2.89f, 0.5f, 1.0f / 60.0f);
controller.set_position(Vec3f(0.0f, 100.0f, 0.0f));
ElapsedTimer elapsed_timer;
float up = 20.0f;
float tilt = 0.0f;
float dir = 0.0f;
float spot_dir = 45.0f;
float aspect_time = 0.0f;
while (!exit)
{
float time_elapsed = elapsed_timer.seconds_elapsed();
// Animate lights:
spot_dir = std::fmod(spot_dir + time_elapsed * 30.0f, 90.0f);
aspect_time = std::fmod(aspect_time + time_elapsed * 0.2f, 2.0f);
spot2.set_aspect_ratio(clamp(aspect_time >= 1.0f ? 2.0f - aspect_time : aspect_time, 0.1f, 1.0f));
spot2.set_orientation(Quaternionf(65.0f + (spot_dir >= 45.0f ? 90.0f - spot_dir : spot_dir), 60.0f, dir * 4.0f, angle_degrees, order_YXZ));
// Update camera orientation:
float dir_speed = 50.0f;
if (window.get_ic().get_keyboard().get_keycode(keycode_left))
{
dir = std::fmod(dir - time_elapsed * dir_speed, 360.0f);
}
else if (window.get_ic().get_keyboard().get_keycode(keycode_right))
{
dir = std::fmod(dir + time_elapsed * dir_speed, 360.0f);
}
float up_speed = 50.0f;
if (window.get_ic().get_keyboard().get_keycode(keycode_up))
{
up = clamp(up - time_elapsed * up_speed, -90.0f, 90.0f);
}
else if (window.get_ic().get_keyboard().get_keycode(keycode_down))
{
up = clamp(up + time_elapsed * up_speed, -90.0f, 90.0f);
}
// Move our character controller:
Quaternionf player_orientation(0.0f, dir, 0.0f, angle_degrees, order_YXZ);
Vec3f move_velocity;
if (window.get_ic().get_keyboard().get_keycode(keycode_w))
{
move_velocity = player_orientation.rotate_vector(Vec3f(0.0f, 0.0f, 1.0f));
}
else if (window.get_ic().get_keyboard().get_keycode(keycode_s))
{
move_velocity = player_orientation.rotate_vector(Vec3f(0.0f, 0.0f, -1.0f));
}
controller.move(move_velocity);
if (window.get_ic().get_keyboard().get_keycode(keycode_space))
{
controller.jump(move_velocity * 0.40f + Vec3f(0.0f, 0.7f, 0.0f));
}
// Update scene player object:
player.set_position(controller.get_position() + Vec3f(0.0f, 1.25f, 0.0f));
player.set_orientation(player_orientation);
// Check for collision between camera and scene:
Quaternionf camera_orientation(up, dir, tilt, angle_degrees, order_YXZ);
float zoom_out = 25.0f;
Vec3f camera_look_pos = controller.get_position();
Vec3f camera_pos = camera_look_pos + camera_orientation.rotate_vector(Vec3f(0.0f, 0.0f, -zoom_out));
if (sweep_test.test_first_hit(sphere_shape, camera_look_pos, Quaternionf(), camera_pos, Quaternionf()))
{
camera_pos = sweep_test.get_hit_position(0);
}
// Update scene camera:
camera.set_orientation(camera_orientation);
camera.set_position(camera_pos);
// Render scene:
scene.update(gc, time_elapsed);
scene.set_viewport(gc.get_size());
scene.render(gc);
// Show result:
window.flip(1);
KeepAlive::process();
}
return 0;
}
void
Navigation::draw(GraphicContext& gc)
{
gc.blit(surface, Point(0, 0));
}
void game::run()
{
//MissileDesc projectile(*this);
towerDesc towr(this);
std::string txt;
std::string txt2 = "Life:";
std::string txt3 = "Money:";
std::string main = "Cam Pos";
std::string txt4 = "Game Over";
std::list<SceneObject *> troll;
endgame = false;
mouseUp = false;
float dir = 0.0f;
float spot_dir = 45.0f;
float aspect_time = 0.0f;
towerCount = 0;
cost = 0;
life = 20;
money = 10;
quit = false;
cameraRestricted = false;
selected_tower = "";
std::stringstream ss2 (std::stringstream::in | std::stringstream::out);
std::stringstream ss3 (std::stringstream::in | std::stringstream::out);
/*GUI app;
int retval = app.main(args);
if (retval == 0)
{
return retval;
}*/
Quaternionf camera_orientation(55.0f, 0.0f, 0.0f, angle_degrees, order_YXZ);
clan::OpenGLWindowDescription opengl_desc;
opengl_desc.set_version(3, 2, false);
clan::OpenGLTarget::set_description(opengl_desc);
//Scene test;
//clan::SceneCamera camera(test);
//DisplayWindowDescription innerwindow("Hello World", Size(640, 480), true);
//innerwindow.set_allow_resize(true);
//innerwindow.set_fullscreen(true);
clan::DisplayWindowDescription win_desc;
win_desc.set_allow_resize(true);
win_desc.set_title("Main");
win_desc.set_size(clan::Size( 1100, 900 ), false);
DisplayWindow window(win_desc);
//DisplayWindow window("main", 1200, 900, false, true);
//window.maximize();
//DisplayWindow window(innerwindow);
Rect viewport = window.get_viewport();
GraphicContext gc = window.get_gc();
ResourceManager resources;
SceneCache::set(resources, std::shared_ptr<SceneCache>(new AppSceneCache()));
ResourceManager sound_resources = XMLResourceManager::create(XMLResourceDocument("../Resources/resources.xml"));
sound_resources_=&sound_resources;
std::string shader_path = "../Resources/Scene3D";
Scene scene(gc, resources, shader_path);
sceneHolder = &scene;
SceneCamera camera(scene);
scene.set_camera(camera);
scene.set_viewport(gc.get_size());
camera.set_orientation(camera_orientation);
camera.set_position(Vec3f(0.0f, 40.0f, down));
Canvas canvas(window);
image_hp = Image(canvas, "../Resources/Images/heart.png");
image_hp.set_alignment(origin_center);
image_hp.set_scale(0.07, 0.07);
image_coin = Image(canvas, "../Resources/Images/coin.png");
image_coin.set_alignment(origin_center);
image_coin.set_scale(0.3, 0.3);
GUIWindowManagerDirect direct(window, canvas);
GUIManager maingui(direct, "../Resources");
GUIComponent *win_comp = new GUIComponent(&maingui, win_desc, "");
radial_menu = new RadialMenu(win_comp);
radial_menu->func_selected.set(this, &game::on_radial_menu_itemselected);
//GameComponent game_component(viewport, &maingui);
/*Rect toolbar_rect = Rect((viewport.get_width() - 448) / 2, viewport.bottom - 56, (viewport.get_width() - 448) / 2 + 448, viewport.bottom);
Toolbar toolbar(toolbar_rect, &game_component); // GameComponent is the "desktop" that the toolbar sits on, as an owner
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell1.png"), Sprite(canvas, "../Resources/Images/spell1_selected.png"), Sprite(canvas, "../Resources/Images/spell1_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell2.png"), Sprite(canvas, "../Resources/Images/spell2_selected.png"), Sprite(canvas, "../Resources/Images/spell2_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell3.png"), Sprite(canvas, "../Resources/Images/spell3_selected.png"), Sprite(canvas, "../Resources/Images/spell3_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell4.png"), Sprite(canvas, "../Resources/Images/spell4_selected.png"), Sprite(canvas, "../Resources/Images/spell4_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell5.png"), Sprite(canvas, "../Resources/Images/spell5_selected.png"), Sprite(canvas, "../Resources/Images/spell5_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell6.png"), Sprite(canvas, "../Resources/Images/spell6_selected.png"), Sprite(canvas, "../Resources/Images/spell6_clicked.png"));
toolbar.add_item(Sprite(canvas, "../Resources/Images/spell7.png"), Sprite(canvas, "../Resources/Images/spell7_selected.png"), Sprite(canvas, "../Resources/Images/spell7_clicked.png"));
*/
InputDevice keyboard = window.get_ic().get_keyboard();
InputDevice mouse = window.get_ic().get_mouse();
clan::Font font(canvas, "Tahoma", 30); // The clan prefix is required on linux due to a namespace conflict
SceneModel plane(gc, scene, "plane");
SceneModel box(gc, scene, "box");
SceneModel tower(gc, scene, "tower");
SceneModel gate(gc,scene,"gate");
SceneObject object(scene, plane, Vec3f(0.0f, 0.0f, 0.0f));
object.rotate(180.0f, 0.0f, 0.0f);
scene.show_skybox_stars(false);
/*SceneObject box0(scene, tower, Vec3f(20.0f, 5.0f, 0.0f), Quaternionf(0.0f, 0.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject box1(scene, tower, Vec3f(-20.0f, 5.0f, 0.0f), Quaternionf(0.0f, 0.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject box2(scene, tower, Vec3f(0.0f, 5.0f, 20.0f), Quaternionf(0.0f, 0.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject box3(scene, tower, Vec3f(0.0f, 5.0f, -20.0f), Quaternionf(0.0f, 0.0f, 0.0f, angle_degrees, order_YXZ));
SceneObject tower[10];*/
SceneObject theGate(scene, gate, Vec3f(-75.0f,5.0f,60.0f), Quaternionf(0.0f,0.0f,0.0f,angle_degrees,order_YXZ));
theGate.set_scale(Vec3f(1.0f,2.0f,2.0f));
std::vector<SceneLight> omni_lights;
for (int i = 0; i < 4; i++)
{
SceneLight omni(scene);
omni.set_type(SceneLight::type_omni);
omni.set_color(Vec3f(0.05f));
omni.set_position(Quaternionf(45.0f, 45.0f + i * 90.0f, 0.0f, angle_degrees, order_YXZ).rotate_vector(Vec3f(0.0f, 0.0f, -100.0f)));
omni.set_attenuation_end(200.0f);
omni.set_ambient_illumination(0.025f);
omni_lights.push_back(omni);
}
SceneLight spot(scene);
spot.set_type(SceneLight::type_spot);
spot.set_orientation(Quaternionf(45.0f, 45.0f, 0.0f, angle_degrees, order_YXZ));
spot.set_position(spot.get_orientation().rotate_vector(Vec3f(-55.0f, 90.0f, -550.0f)));
//spot.set_position(Vec3f(-250, 100, -430));
spot.set_color(Vec3f(1.0f, 1.0f, 0.8f));
spot.set_falloff(45.0f);
spot.set_hotspot(15.0f);
spot.set_attenuation_start(150.0f);
spot.set_attenuation_end(1500.0f);
spot.set_shadow_caster(true);
spot.set_rectangle_shape(false);
//spot.set_ambient_illumination(true);
spot.set_aspect_ratio(1.0f);
/*SceneLight spot(scene);
spot.set_type(SceneLight::type_spot);
spot.set_orientation(Quaternionf(30.0f, 30.0f, 0.0f, angle_degrees, order_YXZ));
spot.set_position(spot.get_orientation().rotate_vector(Vec3f(0.0f, 0.0f, -100.0f)));
spot.set_color(Vec3f(1.0f, 1.0f, 0.8f));
spot.set_falloff(45.0f);
spot.set_hotspot(15.0f);
spot.set_attenuation_start(20.0f);
spot.set_attenuation_end(200.0f);
spot.set_shadow_caster(true);
spot.set_rectangle_shape(false);
spot.set_aspect_ratio(1.0f);*/
/*SceneLight spot2(scene);
spot2.set_type(SceneLight::type_spot);
spot2.set_position(Vec3f(0.0f, 100.0f, 0.0f));
spot2.set_color(Vec3f(1.0f, 1.0f, 1.0f) * 3.0f);
spot2.set_falloff(35.0f);
spot2.set_hotspot(30.0f);
spot2.set_attenuation_start(20.0f);
spot2.set_attenuation_end(130.0f);
spot2.set_shadow_caster(true);
spot2.set_rectangle_shape(false);
spot2.set_ambient_illumination(0.025f);*/
wm.NodeArray[0].setPos(75.0f,1.25f,0.0f);
wm.NodeArray[1].setPos(-60.0f,1.25f,0.0f);
wm.NodeArray[2].setPos(-55.0f,1.25f,-65.0f);
wm.NodeArray[3].setPos(60.0f,1.25f,-60.0f);
wm.NodeArray[4].setPos(55.0f,1.25f,65.0f);
wm.NodeArray[5].setPos(-80.0f,1.25f,60.0f);
Physics3DShape box_shape = Physics3DShape::box(Vec3f(5.0f));
Physics3DShape plane_shape = Physics3DShape::box(Vec3f(75.0f, 1.0f, 75.0f));
Physics3DShape sphere_shape = Physics3DShape::sphere(2.0f);
Physics3DObject phys_plane(physics_world, plane_shape, Vec3f(0.0f, -0.5f, 0.0f));
/*Physics3DObject phys_box0(physics_world, box_shape, Vec3f(20.0f, 5.0f, 0.0f), box0.get_orientation());
Physics3DObject phys_box1(physics_world, box_shape, Vec3f(-20.0f, 5.0f, 0.0f), box1.get_orientation());
Physics3DObject phys_box2(physics_world, box_shape, Vec3f(0.0f, 5.0f, 20.0f), box2.get_orientation());
Physics3DObject phys_box3(physics_world, box_shape, Vec3f(0.0f, 5.0f, -20.0f), box3.get_orientation());
Physics3DObject phys_box[10];*/
Physics3DSweepTest sweep_test(physics_world);
Physics3DRayTest raycast(physics_world);
Slot slot_keyboard_key_down = (window.get_ic().get_keyboard()).sig_key_down() .connect(this,&game::on_key_down);
Slot slot_keyboard_key_up = (window.get_ic().get_keyboard()).sig_key_up() .connect(this,&game::on_key_up);
Slot slot_mouse_moved = (window.get_ic().get_mouse()).sig_pointer_move() .connect(this,&game::on_pointer_move);
Slot slot_mouse_down = (window.get_ic().get_mouse()).sig_key_down() .connect(this,&game::on_pointer_down);
Slot slot_mouse_up = (window.get_ic().get_mouse()).sig_key_up() .connect(this,&game::on_pointer_up);
//________________________________________________________________
// S O U N D S
total_channels=3;
current_channel=1;
SoundBuffer music = SoundBuffer::resource("Music1",sound_resources);
music.set_volume(0.3f);
sound_session1.play();
sound_session2.play();
sound_session3.play();
total_samples = 6;
samples.resize(total_samples);
samples[0] = SoundBuffer::resource("Explosion1",sound_resources);
samples[1] = SoundBuffer::resource("Explosion2",sound_resources);
samples[2] = SoundBuffer::resource("Hurt1",sound_resources);
samples[3] = SoundBuffer::resource("Hurt2",sound_resources);
samples[4] = SoundBuffer::resource("Powerup1",sound_resources);
samples[5] = SoundBuffer::resource("Shoot1",sound_resources);
for(int i = 0; i<total_samples; i++)
{
samples[i].set_volume(0.3f);
}
SoundBuffer_Session music_session = music.prepare();
music_session_ = &music_session;
music_session.set_looping(true);
music_session.play();
is_music_muted = false;
/********Enemies(Jasper)************************/
SceneObject enemyobj[30];
wm.spawnCreeps();
for(int i = 0; i < 30; i ++)
{
enemyobj[i] = SceneObject(scene, box);
enemyobj[i].set_scale(Vec3f(0.25f));
wm.enemyArray[i].setEnemyObject(&enemyobj[i]);
}
/***************************************/
ElapsedTimer elapsed_timer;
while (!quit)
{
float time_elapsed = elapsed_timer.seconds_elapsed();
/*spot_dir = std::fmod(spot_dir + time_elapsed * 30.0f, 90.0f);
aspect_time = std::fmod(aspect_time + time_elapsed * 0.2f, 2.0f);
spot2.set_aspect_ratio(clamp(aspect_time >= 1.0f ? 2.0f - aspect_time : aspect_time, 0.1f, 1.0f));
spot2.set_orientation(Quaternionf(65.0f + (spot_dir >= 45.0f ? 90.0f - spot_dir : spot_dir), 60.0f, dir * 4.0f, angle_degrees, order_YXZ));
*/
// Draw with the canvas:
/*canvas.clear(Colorf::cadetblue);
canvas.draw_line(0, 110, 640, 110, Colorf::yellow);
font.draw_text(canvas, 100, 100, "Hello World!", Colorf::lightseagreen);
// Draw any remaining queued-up drawing commands oQAn canvas:
canvas.flush();*/
if (!endgame)
{
if (mouse.get_x() <= 0 && !cameraRestricted)
{
mouse.set_position(0, mouse.get_y());
camera.set_position(camera.get_position()+Vec3f(-mouse_move_speed, 0.0f, 0.0f));
/*canvas.clear();
font.draw_text(canvas, 100, 100, "x=0", Colorf::lightseagreen);
canvas.flush();*/
//window.flip();
}
if (mouse.get_y() <= 0 && !cameraRestricted)
{
mouse.set_position(mouse.get_x(), 0);
camera.set_position(camera.get_position()+Vec3f(0.0f, 0.0f, mouse_move_speed));
/*canvas.clear();
font.draw_text(canvas, 100, 100, "y=0", Colorf::lightseagreen);
canvas.flush();*/
//window.flip();
}
if (mouse.get_x() >= window.get_gc().get_width()-1 && !cameraRestricted)
{
mouse.set_position(window.get_gc().get_width()-1, mouse.get_y());
camera.set_position(camera.get_position()+Vec3f(mouse_move_speed, 0.0f, 0.0f));
/*canvas.clear();
font.draw_text(canvas, 100, 100, "x=windowRight", Colorf::lightseagreen);
canvas.flush();*/
//window.flip();
}
if (mouse.get_y() >= window.get_gc().get_height()-1 && !cameraRestricted)
{
mouse.set_position(mouse.get_x(), window.get_gc().get_height()-1);
camera.set_position(camera.get_position()+Vec3f(0.0f, 0.0f, -mouse_move_speed));
/*canvas.clear();
font.draw_text(canvas, 100, 100, "y=windowBottom", Colorf::lightseagreen);
canvas.flush();*/
//window.flip();
}
if (mouseUp)
{
if (selected_tower == "Tower 1")
{
towr.set_type(towr.t_bullet);
cost = 10;
}
else if (selected_tower == "Tower 2")
{
towr.set_type(towr.t_energy);
cost = 15;
}
else if (selected_tower == "Tower 3")
{
towr.set_type(towr.t_rocket);
cost = 20;
}
scene.unproject(mouse_pos, start, end);
end *= 151;
test = start + end;
if (raycast.test(start, test))
{
if (towerCount < 10 && money >= cost)
{
towr.set_pos(Vec3f(raycast.get_hit_position().x, 5.0f, raycast.get_hit_position().z));
towr.create(scene, tower, physics_world);
money -= cost;
towerCount++;
cost = 0;
}
}
mouseUp = false;
//float x = mouse.get_x() - scene.world_to_projection().get_origin_x();
//tower[0] = SceneObject(scene, box, Vec3f(camera.get_position().x, 5.0f, camera.get_position().z));
//tower[0].set_position(Vec3f(0.0f, 5.0f, 0.0f));
//window.flip();
//canvas.clear(Colorf::cadetblue);
/*canvas.draw_line(0, 110, 640, 110, Colorf::yellow);
font.draw_text(canvas, 100, 100, "Hello World!", Colorf::lightseagreen);
// Draw any remaining queued-up drawing commands oQAn canvas:
canvas.flush();
// Present the frame buffer content to the user:
window.flip();*/
}
if (mouse.get_keycode(0))
{
//maingui.process_messages(0);
//test.update();
//show_radial_menu(mouse.get_position());
}
/*if (mouse.get_keycode(1))
{
scene.unproject(mouse.get_position(), start, end);
end *= 151;
Vec3f test = start + end;
if (raycast.test(start, test))
{
Physics3DObject hit = raycast.get_hit_object();
font.draw_text(canvas, 400, 100, "hit", Colorf::lightseagreen);
//hit.set_position(Vec3f(0.0f, -10.0f, 0.0f));
std::stringstream ss3 (std::stringstream::in | std::stringstream::out);
ss3 << hit.get_position().y;
txt3 = ss3.str();
font.draw_text(canvas, 550, 100, txt3, Colorf::lightseagreen);
}
//projectile.set_pos(Vec3f(raycast.get_hit_position().x, 5.0f, raycast.get_hit_position().z));
//projectile.fire(scene, box, physics_world);
//canvas.clear(Colorf::white);
//window.flip();
}*/
if (keyboard.get_keycode(keycode_control))
{
if (window.is_fullscreen())
{
//innerwindow.set_fullscreen(false);
window.set_size(640, 480, true);
window.restore();
}
else
window.set_size(640, 480, false);
}
if (camera.get_position().x <= left)
{
camera.set_position(Vec3f(left, camera.get_position().y, camera.get_position().z));
}
if (camera.get_position().x >= right)
{
camera.set_position(Vec3f(right, camera.get_position().y, camera.get_position().z));
}
if (camera.get_position().z >= top)
{
camera.set_position(Vec3f(camera.get_position().x, camera.get_position().y, top));
}
if (camera.get_position().z <= down)
{
camera.set_position(Vec3f(camera.get_position().x, camera.get_position().y, down));
}
/*if(objects_for_deletion.size()>0)
{
std::list<Gameobject *>::iterator it;
for(it=objects_for_deletion.begin(); it!= objects_for_deletion.end(); ++it)
{
delete (*it);
//towerCount--;
}
objects_for_deletion.clear();
}*/
if(towerObjects.size()>0)
{
std::vector<Gameobject *>::iterator it;
int counter = 0;
for(it=towerObjects.begin(); it!= towerObjects.end(); ++it)
{
towerObjects.at(counter)->update(time_elapsed, wm.enemyArray, 30);
counter++;
}
}
if(missileObjects.size()>0)
{
std::list<Gameobject *>::iterator it;
for(it=missileObjects.begin(); it!= missileObjects.end();)
{
//if (!(*it)->checkActive())
(*it)->update(time_elapsed, wm.enemyArray);
if ((*it)->checkActive())
{
delete(*it);
it = missileObjects.erase(it);
}
else
it++;
}
}
/*******Enemies(Updates)************************/
wm.Update(1);
//time_lasttime = time_elapsed;
if(wm.life > 0)
{
// Put a screen here
life -= wm.life;
wm.life = 0;
}
if (wm.currLevel == 3)
{
endgame = true;
}
/***********************************************/
//scene.update(gc, time_elapsed);
txt3 = ":";
ss3.str("");
ss3.clear();
ss3 << money;
txt3 += ss3.str();
font.draw_text(canvas, 550, 50, txt3, Colorf::lightseagreen);
if (life < 0)
{
endgame = true;
}
scene.render(gc);
/*canvas.clear(clan::Colorf(0.0f,0.0f,0.0f));
std::stringstream ss (std::stringstream::in | std::stringstream::out);
ss << game_time.get_time_elapsed();
std::string troll = ss.str();
font.draw_text(canvas, 100, 100, troll, Colorf::lightseagreen);*/
//canvas.clear(clan::Colorf(0.0f,0.0f,0.0f));
std::stringstream ss (std::stringstream::in | std::stringstream::out);
ss << scene.world_to_projection().get_origin_x();
txt = ss.str();
txt2 = ":";
ss2.str("");
ss2.clear();
ss2 << life;
txt2 += ss2.str();
font.draw_text(canvas, 150, 50, txt2, Colorf::lightseagreen);
//maingui.process_messages(0);
/*font.draw_text(canvas, 0, 100, main, Colorf::lightseagreen);
font.draw_text(canvas, 150, 100, txt, Colorf::lightseagreen);
font.draw_text(canvas, 250, 100, txt2, Colorf::lightseagreen);
canvas.draw_line(0, 110, 640, 110, Colorf::yellow);*/
maingui.render_windows();
image_hp.draw(canvas, 100, 45);
image_coin.draw(canvas, 500, 45);
window.flip();
// Read messages from the windowing system message queue, if any are available:
KeepAlive::process();
}
else
{
//maingui.render_windows();
canvas.clear(Colorf::black);
font.draw_text(canvas, 450, 400, txt4, Colorf::lightseagreen);
window.flip();
// Read messages from the windowing system message queue, if any are available:
KeepAlive::process();
}
}
}
void BloomPass::setup_bloom_extract(GraphicContext &gc)
{
Size viewport_size = viewport->get_size();
Size bloom_size = viewport_size / 2;
if (bloom_contribution->is_null() || bloom_contribution->get_size() != bloom_size || !gc.is_frame_buffer_owner(fb_bloom_extract))
{
bloom_contribution.set(Texture2D(gc, bloom_size.width, bloom_size.height, tf_rgba8));
fb_bloom_extract = FrameBuffer(gc);
fb_bloom_extract.attach_color(0, bloom_contribution.get());
bloom_blur.output.set(fb_bloom_extract);
}
}
void LightsourceSimplePass::upload(GraphicContext &gc, Scene_Impl *scene)
{
ScopeTimeFunction();
Size viewport_size = viewport->get_size();
Mat4f eye_to_projection = Mat4f::perspective(field_of_view.get(), viewport_size.width/(float)viewport_size.height, 0.1f, 1.e4f, handed_left, gc.get_clip_z_range());
float aspect = viewport->get_width()/(float)viewport->get_height();
float field_of_view_y_degrees = field_of_view.get();
float field_of_view_y_rad = (float)(field_of_view_y_degrees * PI / 180.0);
float f = 1.0f / tan(field_of_view_y_rad * 0.5f);
float rcp_f = 1.0f / f;
float rcp_f_div_aspect = 1.0f / (f / aspect);
Vec2f two_rcp_viewport_size(2.0f / viewport->get_width(), 2.0f / viewport->get_height());
Uniforms cpu_uniforms;
cpu_uniforms.eye_to_projection = eye_to_projection;
cpu_uniforms.object_to_eye = Quaternionf::inverse(scene->get_camera().get_orientation()).to_matrix();
cpu_uniforms.rcp_f = rcp_f;
cpu_uniforms.rcp_f_div_aspect = rcp_f_div_aspect;
cpu_uniforms.two_rcp_viewport_size = two_rcp_viewport_size;
uniforms.upload_data(gc, &cpu_uniforms, 1);
int num_lights = lights.size();
Mat4f normal_world_to_eye = Mat4f(Mat3f(world_to_eye.get())); // This assumes uniform scale
Mat4f eye_to_world = Mat4f::inverse(world_to_eye.get());
PixelBufferLock4f lock(light_instance_transfer);
Vec4f *instance_data = lock.get_row(0);
for (int i = 0; i < num_lights; i++)
{
float radius = lights[i]->attenuation_end;
if (lights[i]->rectangle_shape)
radius *= 1.414213562373f;
float attenuation_delta = lights[i]->attenuation_end - lights[i]->attenuation_start;
if (attenuation_delta == 0.0f)
attenuation_delta = 1e-6f;
float sqr_radius = radius * radius;
#ifdef USE_QUADRATIC_ATTENUATION
float sqr_attenuation_start = lights[i]->attenuation_start * lights[i]->attenuation_start;
float sqr_attenuation_delta = attenuation_delta * attenuation_delta;
#else
float attenuation_start = lights[i]->attenuation_start;
#endif
float sqr_falloff_begin = 0.0f;
float light_type = 0.0f;
if (lights[i]->type == SceneLight::type_spot)
{
light_type = lights[i]->rectangle_shape ? 2.0f : 1.0f;
float falloff_begin = lights[i]->hotspot / lights[i]->falloff;
sqr_falloff_begin = falloff_begin * falloff_begin;
}
Vec3f position_in_eye = Vec3f(world_to_eye.get() * Vec4f(lights[i]->position, 1.0f));
Mat4f eye_to_shadow_projection = lights[i]->vsm_data->world_to_shadow_projection * eye_to_world;
int shadow_map_index = lights[i]->vsm_data->shadow_map.get_index();
instance_data[i * vectors_per_light + 0] = Vec4f(position_in_eye, (float)shadow_map_index);
instance_data[i * vectors_per_light + 1] = Vec4f(lights[i]->color, lights[i]->ambient_illumination);
#ifdef USE_QUADRATIC_ATTENUATION
instance_data[i * vectors_per_light + 2] = Vec4f(sqr_radius, sqr_attenuation_start, 1.0f / sqr_attenuation_delta, sqr_falloff_begin);
#else
instance_data[i * vectors_per_light + 2] = Vec4f(sqr_radius, attenuation_start, 1.0f / attenuation_delta, sqr_falloff_begin);
#endif
instance_data[i * vectors_per_light + 3] = Vec4f(eye_to_shadow_projection[0], eye_to_shadow_projection[4], eye_to_shadow_projection[8], light_type);
instance_data[i * vectors_per_light + 4] = Vec4f(eye_to_shadow_projection[1], eye_to_shadow_projection[5], eye_to_shadow_projection[9], 0.0f);
instance_data[i * vectors_per_light + 5] = Vec4f(eye_to_shadow_projection[2], eye_to_shadow_projection[6], eye_to_shadow_projection[10], 0.0f);
}
instance_data[num_lights * vectors_per_light + 0] = Vec4f(0.0f);
instance_data[num_lights * vectors_per_light + 1] = Vec4f(0.0f);
instance_data[num_lights * vectors_per_light + 2] = Vec4f(0.0f);
instance_data[num_lights * vectors_per_light + 3] = Vec4f(0.0f);
instance_data[num_lights * vectors_per_light + 4] = Vec4f(0.0f);
instance_data[num_lights * vectors_per_light + 5] = Vec4f(0.0f);
lock.unlock();
light_instance_texture.set_image(gc, light_instance_transfer);
}
void ShaderEffect::draw(GraphicContext &gc)
{
gc.set_program_object(impl->program);
if (!impl->fb.is_null())
gc.set_frame_buffer(impl->fb);
if (!impl->rasterizer_state.is_null())
gc.set_rasterizer_state(impl->rasterizer_state);
if (!impl->blend_state.is_null())
gc.set_blend_state(impl->blend_state);
if (!impl->depth_stencil_state.is_null())
gc.set_depth_stencil_state(impl->depth_stencil_state);
for (auto & elem : impl->uniform_bindings)
{
gc.set_uniform_buffer(elem.first, elem.second);
}
for (auto & elem : impl->storage_bindings)
{
gc.set_storage_buffer(elem.first, elem.second);
}
for (auto & elem : impl->image_bindings)
{
gc.set_image_texture(elem.first, elem.second);
}
for (auto & elem : impl->texture_bindings)
{
gc.set_texture(elem.first, elem.second);
}
if (!impl->elements.is_null())
{
gc.set_primitives_elements(impl->elements);
gc.set_primitives_array(impl->prim_array);
gc.draw_primitives_elements(type_triangles, impl->num_vertices, impl->elements_type);
gc.reset_primitives_array();
gc.reset_primitives_elements();
}
else
{
gc.set_primitives_array(impl->prim_array);
gc.draw_primitives_array(type_triangles, 0, impl->num_vertices);
gc.reset_primitives_array();
}
for (auto & elem : impl->uniform_bindings)
{
gc.reset_uniform_buffer(elem.first);
}
for (auto & elem : impl->storage_bindings)
{
gc.reset_storage_buffer(elem.first);
}
for (auto & elem : impl->image_bindings)
{
gc.reset_image_texture(elem.first);
}
for (auto & elem : impl->texture_bindings)
{
gc.reset_texture(elem.first);
}
if (!impl->rasterizer_state.is_null())
gc.reset_rasterizer_state();
if (!impl->blend_state.is_null())
gc.reset_blend_state();
if (!impl->depth_stencil_state.is_null())
gc.reset_depth_stencil_state();
if (!impl->fb.is_null())
gc.reset_frame_buffer();
gc.reset_program_object();
}
void LightsourceSimplePass::render(GraphicContext &gc, GPUTimer &timer)
{
ScopeTimeFunction();
//timer.begin_time(gc, "light(simple)");
gc.set_frame_buffer(fb);
gc.set_viewport(viewport->get_size());
gc.set_depth_range(0.0f, 0.9f);
gc.set_uniform_buffer(0, uniforms);
gc.set_texture(0, light_instance_texture);
gc.set_texture(1, normal_z_gbuffer.get());
gc.set_texture(2, diffuse_color_gbuffer.get());
gc.set_texture(3, specular_color_gbuffer.get());
gc.set_texture(4, specular_level_gbuffer.get());
gc.set_texture(5, shadow_maps.get());
gc.set_texture(6, self_illumination_gbuffer.get());
gc.set_blend_state(blend_state);
gc.clear();
// To do: use icosahedron for smaller lights and when the camera is not inside the light influence sphere
// To do: combine multiple lights into the same rect pass to reduce overdraw penalty
gc.set_depth_stencil_state(rect_depth_stencil_state);
gc.set_rasterizer_state(rect_rasterizer_state);
gc.set_program_object(rect_light_program);
gc.set_primitives_array(rect_prim_array);
gc.draw_primitives_array_instanced(type_triangles, 0, 6, std::max(lights.size(), (size_t)1));
gc.reset_primitives_array();
/*
gc.set_depth_stencil_state(icosahedron_depth_stencil_state);
gc.set_rasterizer_state(icosahedron_rasterizer_state);
gc.set_program_object(icosahedron_light_program);
gc.set_primitives_array(icosahedron_prim_array);
gc.draw_primitives_elements_instanced(type_triangles, icosahedron->num_elements, icosahedron->elements, 0, lights.size());
gc.reset_primitives_array();
*/
gc.set_depth_stencil_state(icosahedron_depth_stencil_state);
gc.set_rasterizer_state(icosahedron_rasterizer_state);
gc.set_program_object(icosahedron_light_program);
gc.set_primitives_array(icosahedron_prim_array);
gc.draw_primitives_elements_instanced(type_triangles, icosahedron->num_elements, icosahedron->elements, 0, lights.size());
gc.reset_primitives_array();
//timer.end_time(gc);
//timer.begin_time(gc, "light(simple)");
gc.reset_texture(6);
gc.reset_texture(5);
gc.reset_texture(4);
gc.reset_texture(3);
gc.reset_texture(2);
gc.reset_texture(1);
gc.reset_texture(0);
gc.reset_uniform_buffer(0);
//timer.end_time(gc);
}
void Texture2D::copy_image_from(GraphicContext &context, int x, int y, int width, int height, int level, TextureFormat texture_format)
{
impl->provider->copy_image_from(x, y, width, height, level, texture_format, context.get_provider());
}
FrameBuffer::FrameBuffer(GraphicContext &context)
: impl(std::make_shared<FrameBuffer_Impl>())
{
GraphicContextProvider *gc_provider = context.get_provider();
impl->provider = gc_provider->alloc_frame_buffer();
}
void Texture2D::copy_image_from(GraphicContext &context, const Rect &pos, int level, TextureFormat texture_format)
{
impl->provider->copy_image_from(pos.left, pos.top, pos.get_width(), pos.get_height(), level, texture_format, context.get_provider());
}
int App::start(const std::vector<std::string> &args)
{
OpenGLWindowDescription description;
description.set_title("UniformBlock Shader");
//description.set_version(3, 1, false);
description.set_size(Size(1024, 768), true);
DisplayWindow window(description);
InputDevice keyboard = window.get_ic().get_keyboard();
GraphicContext gc = window.get_gc();
Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up);
Slot slot_window_close = window.sig_window_close().connect(this, &App::window_close);
// Load and link shaders
ProgramObject shader = ProgramObject::load(gc, "Resources/vertex_shader.glsl", "Resources/fragment_shader.glsl");
shader.bind_attribute_location(0, "Position");
if (!shader.link())
throw Exception("Unable to link shader program: Error:" + shader.get_info_log());
int block_size = shader.get_uniform_block_size("TestBlock");
const int num_blocks = 16;
ProgramUniformBlock block(gc, block_size * num_blocks);
std::vector<float> data_to_upload;
data_to_upload.resize((num_blocks * block_size) / sizeof(float) );
float test_colour = 1.0f;
for (int cnt=0; cnt<num_blocks; cnt++)
{
int offset = cnt * block_size / sizeof(float) ;
data_to_upload[offset + 0] = test_colour;
data_to_upload[offset + 1] = 0.5f;
data_to_upload[offset + 2] = 1.0f;
test_colour -= 0.05f;
}
block.upload_data(0, &data_to_upload[0], block_size * num_blocks);
quit = false;
Font font(gc, "tahoma", 32);
clan::ubyte64 startTime = System::get_time();
//// Test code
//GLuint uniform_index = -1;
//const char *names[] = {"src_color"};
//glGetUniformIndices(handle, 1, names, &uniform_index);
//if (uniform_index >=0)
//{
// GLint offset;
// GLint singleSize;
// GLint uniform_type;
// glGetActiveUniformsiv(handle, 1, &uniform_index, GL_UNIFORM_TYPE, &uniform_type);
// glGetActiveUniformsiv(handle, 1, &uniform_index, GL_UNIFORM_OFFSET, &offset);
// glGetActiveUniformsiv(handle, 1, &uniform_index, GL_UNIFORM_SIZE, &singleSize);
// if ((uniform_type != GL_FLOAT_VEC3) || (offset !=0) || (singleSize != 1))
// {
// throw Exception("well it seems it does not work");
// }
//}
while (!quit)
{
gc.clear(Colorf(0.1f, 0.1f, 0.2f));
OpenGL::check_error();
for (int test_run_y=0; test_run_y < 16; test_run_y++)
{
shader.set_uniform_block("TestBlock", block, test_run_y*block_size);
for (int test_run_x=0; test_run_x < 16; test_run_x++)
{
Vec2f positions[3];
float size = 32.0f;
positions[0].x = test_run_x * size;
positions[0].y = test_run_y * size + size;
positions[1].x = test_run_x * size + size;
positions[1].y = test_run_y * size + size;
positions[2].x = test_run_x * size + size;
positions[2].y = test_run_y * size;
PrimitivesArray prim_array(gc);
prim_array.set_attributes(0, positions);
gc.set_program_object(shader, cl_program_matrix_modelview_projection);
gc.draw_primitives(cl_triangles, 3, prim_array);
gc.reset_program_object();
}
}
font.draw_text(gc, 32, 200, "Hello World");
window.flip(1);
KeepAlive::process();
}
return 0;
}
// The start of the Application
int App::start(const std::vector<std::string> &args)
{
try
{
DisplayWindowDescription win_desc;
win_desc.set_allow_resize(true);
win_desc.set_title("HDR Example");
win_desc.set_size(Size( 600, 630 ), false);
DisplayWindow window(win_desc);
Slot slot_quit = window.sig_window_close().connect(this, &App::on_window_close);
Slot slot_input_up = (window.get_ic().get_keyboard()).sig_key_up().connect(this, &App::on_input_up);
GraphicContext gc = window.get_gc();
// Load and link shaders
ProgramObject shader = ProgramObject::load(gc, "Resources/vertex_shader.glsl", "Resources/fragment_shader.glsl");
shader.bind_attribute_location(0, "Position");
shader.bind_attribute_location(2, "TexCoord0");
if (!shader.link())
throw Exception("Unable to link shader program: Error:" + shader.get_info_log());
const float dynamic_range_start = -1.5f;
const float dynamic_range_end = 1.5f;
const Size image_size(gc.get_width() - 64, 128);
Texture image_rgb32f = create_rgb32f(gc, image_size, dynamic_range_start, dynamic_range_end);
Font font(gc, "Tahoma", 20);
clan::ubyte64 time_last = System::get_time();
bool direction = false;
while (!quit)
{
clan::ubyte64 time_now = System::get_time();
time_delta = ((float) time_now - time_last) / 1000.0f;
time_last = time_now;
if (direction)
{
color_offset.r += time_delta * 1.0f;
if (color_offset.r > 2.0f)
{
color_offset.r = 2.0f;
direction = false;
}
}
else
{
color_offset.r -= time_delta * 1.0f;
if (color_offset.r < -2.0f)
{
color_offset.r = -2.0f;
direction = true;
}
}
color_offset.g = color_offset.r;
color_offset.b = color_offset.r;
gc.clear(Colorf(0.2f,0.2f,0.5f));
font.draw_text(gc, 32, 50, "Showing Texture RGB values from " + StringHelp::float_to_text(dynamic_range_start) + " to " + StringHelp::float_to_text(dynamic_range_end));
draw_image(gc, image_rgb32f, 32.0f, 100.0f, shader, Vec4f(0.0f, 0.0f, 0.0f, 0.0f));
font.draw_text(gc, 32, 350, "Showing Texture with an offset to the floating point color component");
draw_image(gc, image_rgb32f, 32.0f, 400.0f, shader, color_offset);
KeepAlive::process(0);
window.flip(1);
}
}
catch(Exception &exception)
{
// Create a console window for text-output if not available
ConsoleWindow console("Console", 80, 160);
Console::write_line("Exception caught: " + exception.get_message_and_stack_trace());
console.display_close_message();
return -1;
}
return 0;
}
