void FlyingCamera::move_forward(GLfloat distance) {
glm::mat3 rotation = glm::mat3_cast(get_forward());
// The order of multiplication is reversed... now it seems to be working quite fine.
glm::vec3 axis_of_motion = get_forward_dir()*rotation;
// axis_of_motion should be normalized
glm::vec3 position3 = glm::vec3(get_position().x,get_position().y,get_position().z);
glm::vec3 new_position = position3 + axis_of_motion*distance;
set_position(glm::vec4(new_position.x,new_position.y,new_position.z,1));
}
void bc_perspective_camera::get_extend_points(extend& p_points) const
{
auto l_fov_tan = 2 * std::tanf(m_field_of_view / 2);
auto l_near_clip_height = l_fov_tan * get_near_clip();
auto l_near_clip_width = l_near_clip_height * m_aspect_ratio;
auto l_far_clip_height = l_fov_tan * get_far_clip();
auto l_far_clip_width = l_far_clip_height * m_aspect_ratio;
auto l_near_clip_center = get_position() + get_forward() * get_near_clip();
auto l_far_clip_center = get_position() + get_forward() * get_far_clip();
p_points[0] = l_near_clip_center + get_left() * (l_near_clip_width / 2) + get_down() * (l_near_clip_height / 2);
p_points[1] = l_near_clip_center + get_left() * (l_near_clip_width / 2) + get_up() * (l_near_clip_height / 2);
p_points[2] = l_near_clip_center + get_right() * (l_near_clip_width / 2) + get_up() * (l_near_clip_height / 2);
p_points[3] = l_near_clip_center + get_right() * (l_near_clip_width / 2) + get_down() * (l_near_clip_height / 2);
p_points[4] = l_far_clip_center + get_left() * (l_far_clip_width / 2) + get_down() * (l_far_clip_height / 2);
p_points[5] = l_far_clip_center + get_left() * (l_far_clip_width / 2) + get_up() * (l_far_clip_height / 2);
p_points[6] = l_far_clip_center + get_right() * (l_far_clip_width / 2) + get_up() * (l_far_clip_height / 2);
p_points[7] = l_far_clip_center + get_right() * (l_far_clip_width / 2) + get_down() * (l_far_clip_height / 2);
}
void geometry2d_renderer::render(renderer_ptr render)
{
if (game_obj_.expired())
{
return;
}
auto obj = game_obj_.lock();
if (!obj->get_active())
{
return;
}
auto trans = obj->get_component<transform2d>();
assert_return((trans != nullptr));
if (geo_type_ == gt_none)
{
return;
}
vert_buf_.clear();
if (geo_type_ == gt_polygon)
{
auto mat = matrix3::make_transform(trans->get_pos(), trans->get_scale(), trans->get_forward());
for (auto vt : geo_data_.vertices)
{
vert_buf_.push_back(mat * vt);
}
}
else if (geo_type_ == gt_circle)
{
static const int vert_cnt = 180;
float scale_factor = 100.0f;
vec2 scale = trans->get_scale();
vec2 pos = trans->get_pos();
for (int i = 0; i < vert_cnt; ++i)
{
float delta = 360.0f / vert_cnt;
float rad = (float)(i * delta * PI) / 180.0f;
vec2 pt;
pt.x = scale_factor * cosf(rad) * geo_data_.radius * scale.x / scale_factor + pos.x;
pt.y = scale_factor * sinf(rad) * geo_data_.radius * scale.y / scale_factor + pos.y;
vert_buf_.push_back(pt);
}
vec2 st = vert_buf_[0];
vert_buf_.push_back(st);
}
else
{
return;
}
render->set_draw_color(vert_color_);
render->draw_polygon(vert_buf_);
}
HeapPtr par_evacuate(HeapPtr heapcell, deque *deq, int me) {
switch(heapcell[0])
{
case SIMPLE_OBJECT:
SimpleObject *sobj = (SimpleObject *)par_allocToSpace(vmsizeof(SimpleObject), heapcell, me);
if(!sobj) return (HeapPtr)get_forward(heapcell);
*sobj = *((SimpleObject *)heapcell);
return sobj;
case POINTER_OBJECT:
PointerObject pobj = (PointerObject *)par_allocToSpace(objsize(heapcell), heapcell, me);
if(!pobj) return (HeapPtr)get_forward(heapcell);
*pobj = *((PointerObject *)heapcell);
pobj->pointers = pobj + vmsizeof(PointerObject);
for(int i = 0; i < pobj->sizePoint; i++)
{
pobj->pointers[i] = ((PointerObject *)heapcell)->pointers[i];
deque_push_bottom(deq, &pobj->pointers[i]);
}
return pobj;
}
}
core::bc_vector3f bc_icamera::get_back() const noexcept
{
return get_forward() * -1;
}
void graph_miner_mpi_dyn::regenerate_embeddings(Projected &projected, int dfs_level)
{
// We don't need to check if the pattern is frequent or minimal
DEBUG(*(graph_miner::logger), "DFS level inside regenerate embeddings = " << dfs_level << " queue size = " << dfs_task_queue[dfs_level].size());
//not necessary though, as task split is not done while regenerating embeddings
//current_dfs_level = dfs_level + 1;
//iterate for all in the task_queue
for(int i = 0; dfs_task_queue[dfs_level].size() > 0; i++) {
types::DFS dfs = dfs_task_queue[dfs_level].front();
dfs_task_queue[dfs_level].pop_front();
current_dfs_level = dfs_level;
load_balance();
DFS_CODE.push(dfs.from, dfs.to, dfs.fromlabel, dfs.elabel, dfs.tolabel);
DEBUG(*(graph_miner::logger), "*****regenerating embeddings for code: " << DFS_CODE.to_string() );
//const RMPath &rmpath = DFS_CODE.buildRMPath();
//int minlabel = DFS_CODE[0].fromlabel;
//int maxtoc = DFS_CODE[rmpath[0]].to;
Projected new_root;
for(unsigned int n = 0; n < projected.size(); ++n) {
unsigned int id = projected[n].id;
PDFS *cur = &projected[n];
History history(graph, cur);
if(dfs.is_backward() ) {
Edge *e = get_backward(graph, DFS_CODE, history);
if(e)
new_root.push(id, e, cur);
}else{
types::EdgeList edges;
if(get_forward(graph, DFS_CODE, history, edges)) {
for(types::EdgeList::iterator it = edges.begin(); it != edges.end(); ++it) {
new_root.push(id, *it, cur);
}
}
}
}
if( embeddings_regeneration_level > dfs_level ) {
regenerate_embeddings(new_root, dfs_level + 1);
}else{
//regeneration of embeddings ended
//now perform regular extensions with project function
//reset embeddings_regeneration_level
//embeddings_regeneration_level = 0;
project(new_root, dfs_level + 1);
}
DFS_CODE.pop();
}
//current_dfs_level = dfs_level;
return;
}
void bc_free_camera::update(core_platform::bc_clock::update_param p_clock_update_param,
const platform::bc_pointing_device& p_pointing_device,
const platform::bc_key_device& p_key_device)
{
core::bc_vector3f l_position = get_position();
bcFLOAT l_move_speed = m_shift_pressed ? m_move_speed * 6 : m_ctrl_pressed ? m_move_speed * 0.25 : m_move_speed;
bcFLOAT l_rotate_speed = m_rotate_speed;
l_move_speed *= p_clock_update_param.m_elapsed_second;
l_rotate_speed *= p_clock_update_param.m_elapsed_second;
if (m_w_pressed)
{
l_position += get_forward() * l_move_speed;
}
if (m_s_pressed)
{
l_position += get_back() * l_move_speed;
}
if (m_a_pressed)
{
l_position += get_left() * l_move_speed;
}
if (m_d_pressed)
{
l_position += get_right() * l_move_speed;
}
if (m_e_pressed)
{
l_position += get_down() * l_move_speed;
}
if (m_q_pressed)
{
l_position += get_up() * l_move_speed;
}
core::bc_vector3f l_direction = get_direction();
if (m_rmb_pressed)
{
bcFLOAT l_pi = 3.14159265358979323846 / 2;
auto l_dx = -m_dx * l_rotate_speed;
auto l_dy = m_dy * l_rotate_speed;
if (m_dy > l_pi)
{
m_dy = l_pi;
}
if (m_dy < -l_pi)
{
m_dy = -l_pi;
}
core::bc_matrix3f l_rotation_y;
core::bc_matrix3f l_rotation_x;
core::bc_matrix3f l_rotation;
core::bc_vector3f l_right = get_right();
core::bc_vector3f l_up = get_up();
if(graphic::bc_render_api_info::is_left_handed())
{
l_rotation_y.rotation_euler_lh(l_up, -l_dx);
l_rotation_x.rotation_euler_lh(l_right, l_dy);
}
else
{
l_rotation_y.rotation_euler_rh(l_up, -l_dx);
l_rotation_x.rotation_euler_rh(l_right, l_dy);
}
l_rotation = l_rotation_y * l_rotation_x;
l_direction = l_rotation * l_direction;
l_direction.normalize();
}
auto l_lookat = l_position + l_direction;
set_look_at(l_position, l_lookat, core::bc_vector3f(0, 1, 0));
m_dx = 0;
m_dy = 0;
}
void FlyingCamera::roll(GLfloat angle) {
glm::fquat quaternion = create_quaternion(get_forward_dir(),angle);
set_up(quaternion*get_up());
set_forward(quaternion * get_forward());
}
void FlyingCamera::pitch(GLfloat angle) {
glm::fquat quaternion = create_quaternion(glm::cross(get_forward_dir(),get_up_dir()),angle);
set_forward(quaternion*get_forward());
set_up(quaternion*get_up());
}
void Camera::move_forward_xy(const float &distance) {
position += get_forward().get_ij().normalized() * distance;
}
void Camera::adjust_roll(const float &rho) {
orientation = Quaternion::Axis_Angle(get_forward(), rho) * orientation;
}
