Example #1
0
d_define_method_override(container, event)(struct s_object *self, struct s_object *environment, SDL_Event *current_event) {
  d_using(container);
  struct s_eventable_attributes *eventable_attributes;
  struct s_uiable_attributes *uiable_attributes;
  struct s_container_drawable *current_container;
  struct s_object *result = d_call_owner(self, uiable, m_eventable_event, environment, current_event);
  struct s_exception *exception;
  d_try
      {
        d_foreach(&(container_attributes->entries), current_container, struct s_container_drawable) {
          if (((uiable_attributes = d_cast(current_container->drawable, uiable))) &&
              ((eventable_attributes = d_cast(current_container->drawable, eventable)))) {
            d_call_owner(current_container->drawable, uiable, m_eventable_event, environment, current_event);
            if ((uiable_attributes->is_selected) && (eventable_attributes->enable))
              d_call(current_container->drawable, m_eventable_event, environment, current_event);
          }
        }
      }
    d_catch(exception)
      {
        d_exception_dump(stderr, exception);
        d_raise;
      }
  d_endtry;
  return result;
}
Example #2
0
d_define_method_override(container, draw)(struct s_object *self, struct s_object *environment) {
  d_using(container);
  struct s_drawable_attributes *drawable_attributes_self = d_cast(self, drawable), *drawable_attributes_entry;
  struct s_uiable_attributes *uiable_attributes_self = d_cast(self, uiable), *uiable_attributes_entry;
  struct s_square_attributes *square_attributes;
  struct s_environment_attributes *environment_attributes = d_cast(environment, environment);
  struct s_camera_attributes *camera_attributes = d_cast(environment_attributes->current_camera, camera);
  struct s_container_drawable *current_container;
  double position_x_self, position_y_self, normalized_position_x_self, normalized_position_y_self, position_x_entry, position_y_entry, center_x_self,
    center_y_self, center_x_entry, center_y_entry, max_w = container_attributes->border_left + container_attributes->border_right,
    max_h = container_attributes->border_top + container_attributes->border_bottom, current_w, current_h;
  int result = d_drawable_return_last;
  d_call(&(drawable_attributes_self->point_destination), m_point_get, &position_x_self, &position_y_self);
  d_call(&(drawable_attributes_self->point_normalized_destination), m_point_get, &normalized_position_x_self, &normalized_position_y_self);
  d_call(&(drawable_attributes_self->point_center), m_point_get, &center_x_self, &center_y_self);
  d_foreach(&(container_attributes->entries), current_container, struct s_container_drawable) {
    drawable_attributes_entry = d_cast(current_container->drawable, drawable);
    position_x_entry = position_x_self + current_container->position_x + container_attributes->border_left;
    position_y_entry = position_y_self + current_container->position_y + container_attributes->border_top;
    center_x_entry = (position_x_self + center_x_self) - position_x_entry;
    center_y_entry = (position_y_self + center_y_self) - position_y_entry;
    d_call(current_container->drawable, m_drawable_set_position, position_x_entry, position_y_entry);
    if (((drawable_attributes_entry->flags & e_drawable_kind_ui_no_attribute_angle) != e_drawable_kind_ui_no_attribute_angle) &&
        ((drawable_attributes_entry->flags & e_drawable_kind_ui_no_attribute_zoom) != e_drawable_kind_ui_no_attribute_zoom))
      d_call(current_container->drawable, m_drawable_set_center, center_x_entry, center_y_entry);
    if ((drawable_attributes_entry->flags & e_drawable_kind_ui_no_attribute_angle) != e_drawable_kind_ui_no_attribute_angle)
      drawable_attributes_entry->angle = drawable_attributes_self->angle;
    if ((drawable_attributes_entry->flags & e_drawable_kind_ui_no_attribute_zoom) != e_drawable_kind_ui_no_attribute_zoom)
      drawable_attributes_entry->zoom = container_attributes->distributed_zoom;
    if ((drawable_attributes_entry->flags & e_drawable_kind_ui_no_attribute_flip) != e_drawable_kind_ui_no_attribute_flip)
      drawable_attributes_entry->flip = drawable_attributes_self->flip;
    if ((d_call(current_container->drawable, m_drawable_normalize_scale, camera_attributes->scene_reference_w, camera_attributes->scene_reference_h,
      camera_attributes->scene_offset_x, camera_attributes->scene_offset_y, camera_attributes->scene_center_x, camera_attributes->scene_center_y,
      camera_attributes->screen_w, camera_attributes->screen_h, camera_attributes->scene_zoom))) {
      square_attributes = d_cast(&(drawable_attributes_entry->square_collision_box), square);
      current_w = d_math_max(d_math_max(square_attributes->normalized_top_left_x, square_attributes->normalized_top_right_x),
                    d_math_max(square_attributes->normalized_bottom_left_x, square_attributes->normalized_bottom_right_x)) - normalized_position_x_self;
      current_h = d_math_max(d_math_max(square_attributes->normalized_top_left_y, square_attributes->normalized_top_right_y),
                    d_math_max(square_attributes->normalized_bottom_left_y, square_attributes->normalized_bottom_right_y)) - normalized_position_y_self;
      if ((uiable_attributes_entry = d_cast(current_container->drawable, uiable))) {
        /* we need to take in consideration the border of the object that is not considered in the collision square */
        current_w += uiable_attributes_entry->border_w;
        current_h += uiable_attributes_entry->border_h;
      }
      /* normalization for ratio and environmental zoom */
      current_w = ((current_w * camera_attributes->scene_reference_w) / camera_attributes->screen_w) / camera_attributes->scene_zoom;
      current_h = ((current_h * camera_attributes->scene_reference_h) / camera_attributes->screen_h) / camera_attributes->scene_zoom;
      max_w = d_math_max(max_w, current_w);
      max_h = d_math_max(max_h, current_h);
    }
  }
  d_call(self, m_drawable_set_dimension, (max_w + uiable_attributes_self->border_w), (max_h + uiable_attributes_self->border_h));
  if ((d_call(self, m_drawable_normalize_scale, camera_attributes->scene_reference_w, camera_attributes->scene_reference_h, camera_attributes->scene_offset_x,
    camera_attributes->scene_offset_y, camera_attributes->scene_center_x, camera_attributes->scene_center_y, camera_attributes->screen_w,
    camera_attributes->screen_h, camera_attributes->scene_zoom))) {
    result = (intptr_t)d_call_owner(self, uiable, m_drawable_draw, environment); /* recall the father's draw method */
    d_foreach(&(container_attributes->entries), current_container, struct s_container_drawable)
      while (((intptr_t)d_call(current_container->drawable, m_drawable_draw, environment)) == d_drawable_return_continue);
  }
Example #3
0
d_define_method_override(label, set_dimension_h)(struct s_object *self, double h) {
    d_using(label);
    struct s_drawable_attributes *drawable_attributes = d_cast(self, drawable);
    struct s_object *result = d_call_owner(self, drawable, m_drawable_set_dimension_h, h);
    label_attributes->last_height = h;
    label_attributes->format = e_label_background_format_fixed;
    d_call(&(drawable_attributes->point_center), m_point_set_y, (double)(label_attributes->last_height/2.0));
    return result;
}
Example #4
0
d_define_method_override(checkbox, draw)(struct s_object *self, struct s_object *environment) {
    d_using(checkbox);
    struct s_uiable_attributes *uiable_attributes = d_cast(self, uiable);
    struct s_environment_attributes *environment_attributes = d_cast(environment, environment);
    struct s_drawable_attributes *drawable_attributes_self = d_cast(self, drawable),
                                 *drawable_attributes_selected;
    struct s_object *selected_component = NULL;
    double position_x, position_y, new_position_x, new_position_y, center_x, center_y, new_center_x, new_center_y, dimension_w_self, dimension_h_self,
           dimension_w_selected, dimension_h_selected, new_dimension_w, new_dimension_h;
    int result = (intptr_t)d_call_owner(self, label, m_drawable_draw, environment); /* recall the father's draw method */
    d_call(&(drawable_attributes_self->point_destination), m_point_get, &position_x, &position_y);
    d_call(&(drawable_attributes_self->point_dimension), m_point_get, &dimension_w_self, &dimension_h_self);
    d_call(&(drawable_attributes_self->point_center), m_point_get, &center_x, &center_y);
    if ((checkbox_attributes->is_checked) && (checkbox_attributes->checked))
        selected_component = checkbox_attributes->checked;
    else if ((!checkbox_attributes->is_checked) && (checkbox_attributes->unchecked))
        selected_component = checkbox_attributes->unchecked;
    if (selected_component) {
        drawable_attributes_selected = d_cast(selected_component, drawable);
        d_call(&(drawable_attributes_selected->point_dimension), m_point_get, &dimension_w_selected, &dimension_h_selected);
        new_dimension_h = dimension_h_self - (uiable_attributes->border_h * 2.0);
        new_dimension_w = (dimension_w_selected * new_dimension_h)/dimension_h_selected;
        new_position_x = position_x + dimension_w_self - new_dimension_w - uiable_attributes->border_w;
        new_position_y = position_y + ((dimension_h_self - new_dimension_h) / 2.0);
        new_center_x = (position_x + center_x) - new_position_x;
        new_center_y = (position_y + center_y) - new_position_y;
        d_call(selected_component, m_drawable_set_position, new_position_x, new_position_y);
        d_call(selected_component, m_drawable_set_center, new_center_x, new_center_y);
        d_call(selected_component, m_drawable_set_dimension, new_dimension_w, new_dimension_h);
        drawable_attributes_selected->angle = drawable_attributes_self->angle;
        drawable_attributes_selected->zoom = drawable_attributes_self->zoom;
        drawable_attributes_selected->flip = drawable_attributes_self->flip;
        if ((d_call(selected_component, m_drawable_normalize_scale, environment_attributes->reference_w[environment_attributes->current_surface],
                        environment_attributes->reference_h[environment_attributes->current_surface],
                        environment_attributes->camera_origin_x[environment_attributes->current_surface],
                        environment_attributes->camera_origin_y[environment_attributes->current_surface],
                        environment_attributes->camera_focus_x[environment_attributes->current_surface],
                        environment_attributes->camera_focus_y[environment_attributes->current_surface],
                        environment_attributes->current_w,
                        environment_attributes->current_h,
                        environment_attributes->zoom[environment_attributes->current_surface])))
            while(((int)d_call(selected_component, m_drawable_draw, environment)) == d_drawable_return_continue);
    }
    d_cast_return(result);
}
Example #5
0
d_define_method_override(label, draw)(struct s_object *self, struct s_object *environment) {
	d_using(label);
	double position_x, position_y, dimension_w, dimension_h, center_x, center_y;
	struct s_drawable_attributes *drawable_attributes = d_cast(self, drawable);
	struct s_environment_attributes *environment_attributes = d_cast(environment, environment);
	SDL_Rect destination;
	SDL_Point center;
	d_call_owner(self, uiable, m_drawable_draw, environment); /* recall the father's draw method */
	d_call(&(drawable_attributes->point_normalized_destination), m_point_get, &position_x, &position_y);
	d_call(&(drawable_attributes->point_normalized_dimension), m_point_get, &dimension_w, &dimension_h);
	d_call(&(drawable_attributes->point_normalized_center), m_point_get, &center_x, &center_y);
	destination.x = position_x;
	destination.y = position_y;
	destination.w = dimension_w;
	destination.h = dimension_h;
	center.x = center_x;
	center.y = center_y;
	SDL_RenderCopyEx(environment_attributes->renderer, label_attributes->image, NULL, &destination, drawable_attributes->angle, &center,
			drawable_attributes->flip);
	d_cast_return(d_drawable_return_last);
}
Example #6
0
d_define_method_override(label, draw)(struct s_object *self, struct s_object *environment) {
    d_using(label);
    struct s_drawable_attributes *drawable_attributes = d_cast(self, drawable);
    struct s_uiable_attributes *uiable_attributes = d_cast(self, uiable);
    struct s_environment_attributes *environment_attributes = d_cast(environment, environment);
    double position_x, position_y, dimension_w, dimension_h, center_x, center_y, width_factor, height_factor;
    int result = (intptr_t)d_call_owner(self, uiable, m_drawable_draw, environment); /* recall the father's draw method */
    SDL_Rect source, destination;
    SDL_Point center;
    if (label_attributes->image) {
        d_call(&(drawable_attributes->point_normalized_destination), m_point_get, &position_x, &position_y);
        d_call(&(drawable_attributes->point_normalized_dimension), m_point_get, &dimension_w, &dimension_h);
        d_call(&(drawable_attributes->point_normalized_center), m_point_get, &center_x, &center_y);
        width_factor = (dimension_w/label_attributes->last_width);
        height_factor = (dimension_h/label_attributes->last_height);
        source.x = 0;
        source.y = 0;
        destination.x = (position_x + uiable_attributes->border_w);
        destination.y = (position_y + uiable_attributes->border_h);
        if (label_attributes->format == e_label_background_format_fixed) {
            source.w = d_math_min((label_attributes->last_width - (uiable_attributes->border_w * 2.0)), label_attributes->string_width);
            source.h = d_math_min((label_attributes->last_height - (uiable_attributes->border_h * 2.0)), label_attributes->string_height);
            switch (label_attributes->alignment_x) {
                case e_label_alignment_center:
                    if ((source.x = d_math_max(((label_attributes->string_width-label_attributes->last_width)/2.0), 0)) == 0)
                        destination.x = position_x + (((label_attributes->last_width - label_attributes->string_width)/2.0) *
                                width_factor);
                    break;
                case e_label_alignment_right:
                    if ((source.x = d_math_max((label_attributes->string_width-label_attributes->last_width), 0)) == 0)
                        destination.x = position_x + ((label_attributes->last_width - label_attributes->string_width) * width_factor);
                default:
                    break;
            }
            switch (label_attributes->alignment_y) {
                case e_label_alignment_center:
                    if ((source.y = d_math_max(((label_attributes->string_height-label_attributes->last_height)/2.0), 0)) == 0)
                        destination.y = position_y + (((label_attributes->last_height - label_attributes->string_height)/2.0) *
                                height_factor);
                    break;
                case e_label_alignment_bottom:
                    if ((source.y = d_math_max((label_attributes->string_height-label_attributes->last_height), 0)) == 0)
                        destination.y = position_y + ((label_attributes->last_height - label_attributes->string_height) *
                                height_factor);
                default:
                    break;
            }
        } else if (label_attributes->format == e_label_background_format_adaptable) {
            source.w = label_attributes->string_width;
            source.h = label_attributes->string_height;
        }
        destination.w = source.w * width_factor;
        destination.h = source.h * height_factor;
        center.x = (position_x + center_x) - destination.x;
        center.y = (position_y + center_y) - destination.y;
        label_attributes->last_source = source;
        label_attributes->last_destination = destination;
        SDL_RenderCopyEx(environment_attributes->renderer, label_attributes->image, &source, &destination, drawable_attributes->angle, &center,
                (SDL_RendererFlip)drawable_attributes->flip);
    }
    d_cast_return(result);
}
d_define_method_override(illuminable_bitmap, draw)(struct s_object *self, struct s_object *environment) {
  d_using(illuminable_bitmap);
  struct s_environment_attributes *environment_attributes = d_cast(environment, environment);
  struct s_drawable_attributes *drawable_attributes = d_cast(self, drawable);
  struct s_lights_emitter_description *lights_emitter;
  struct s_list affected_lights;
  struct s_object *result = d_call_owner(self, bitmap, m_drawable_draw, environment); /* recall the father's draw method */
  double image_x, image_y, image_center_x, image_center_y, image_principal_point_x, image_principal_point_y, new_x, new_y,
    radians_rotation = -(drawable_attributes->angle * d_math_radians_conversion), radians_incident, cosine = cos(radians_rotation),
    sine = sin(radians_rotation), light_normalized_percentage[e_illuminable_bitmap_side_NULL], light_final_mask[e_illuminable_bitmap_side_NULL], local_factor,
    center_factor, center_factor_reduction;
  unsigned int index_side;
  if (illuminable_bitmap_attributes->lights) {
    memset(&(affected_lights), 0, sizeof(s_list));
    for (index_side = 0; index_side < e_illuminable_bitmap_side_NULL; ++index_side)
      light_final_mask[index_side] = 0;
    d_call(self, m_drawable_get_scaled_position, &image_x, &image_y);
    d_call(self, m_drawable_get_scaled_center, &image_center_x, &image_center_y);
    d_call(self, m_drawable_get_scaled_principal_point, &image_principal_point_x, &image_principal_point_y);
    d_call(illuminable_bitmap_attributes->lights, m_lights_get_affecting_lights, self, &(affected_lights), environment);
    d_foreach(&(affected_lights), lights_emitter, struct s_lights_emitter_description) {
      for (index_side = 0; index_side < e_illuminable_bitmap_side_NULL; ++index_side)
        light_normalized_percentage[index_side] = 0;
      /* we need to re-calculate the coordinates of the light in respect of the angle generated by this image */
      new_x = lights_emitter->position_x - (image_x + image_center_x);
      new_y = lights_emitter->position_y - (image_y + image_center_y);
      lights_emitter->position_x = (new_x * cosine) - (new_y * sine) + (image_x + image_center_x);
      lights_emitter->position_y = (new_x * sine) + (new_y * cosine) + (image_y + image_center_y);
      radians_incident = fmod(atan2(lights_emitter->position_y - image_principal_point_y, lights_emitter->position_x - image_principal_point_x), d_math_two_pi);
      /* we need to convert it to a positive angle */
      if (radians_incident < 0)
        radians_incident = d_math_two_pi + radians_incident;
      center_factor_reduction = 0.0;
      switch (illuminable_bitmap_attributes->main_axis) {
        case e_illuminable_bitmap_axis_x:
          center_factor = 1.0 - (fabs(lights_emitter->position_x - image_principal_point_x) / ((image_principal_point_x + lights_emitter->radius) - image_x));
          if ((intptr_t)d_call(&(drawable_attributes->square_collision_box), m_square_inside_coordinates, lights_emitter->position_x,
            lights_emitter->position_y))
            center_factor_reduction = 1.0 - (fabs(lights_emitter->position_x - image_principal_point_x) / (image_principal_point_x - image_x));
          break;
        case e_illuminable_bitmap_axis_y:
          center_factor = 1.0 - (fabs(lights_emitter->position_y - image_principal_point_y) / ((image_principal_point_y + lights_emitter->radius) - image_y));
          if ((intptr_t)d_call(&(drawable_attributes->square_collision_box), m_square_inside_coordinates, lights_emitter->position_x,
            lights_emitter->position_y))
            center_factor_reduction = 1.0 - (fabs(lights_emitter->position_y - image_principal_point_y) / (image_principal_point_y - image_y));
          break;
      }
      light_normalized_percentage[e_illuminable_bitmap_side_front] = center_factor;
      if ((radians_incident >= 0) && (radians_incident < d_math_half_pi)) {
        light_normalized_percentage[e_illuminable_bitmap_side_bottom] = (radians_incident / d_math_half_pi) * (1.0 - center_factor_reduction);
        light_normalized_percentage[e_illuminable_bitmap_side_right] = (1.0 - (radians_incident / d_math_half_pi)) * (1.0 - center_factor_reduction);
      } else if ((radians_incident >= d_math_half_pi) && (radians_incident < d_math_pi)) {
        light_normalized_percentage[e_illuminable_bitmap_side_left] = ((radians_incident - d_math_half_pi) / d_math_half_pi) * (1.0 - center_factor_reduction);
        light_normalized_percentage[e_illuminable_bitmap_side_bottom] =
          (1.0 - ((radians_incident - d_math_half_pi) / d_math_half_pi)) * (1.0 - center_factor_reduction);
      } else if ((radians_incident >= d_math_pi) && (radians_incident < (d_math_pi + d_math_half_pi))) {
        light_normalized_percentage[e_illuminable_bitmap_side_top] = ((radians_incident - d_math_pi) / d_math_half_pi) * (1.0 - center_factor_reduction);
        light_normalized_percentage[e_illuminable_bitmap_side_left] =
          (1.0 - ((radians_incident - d_math_pi) / d_math_half_pi)) * (1.0 - center_factor_reduction);
      } else if ((radians_incident >= (d_math_pi + d_math_half_pi)) && (radians_incident < d_math_two_pi)) {
        light_normalized_percentage[e_illuminable_bitmap_side_right] =
          ((radians_incident - (d_math_pi + d_math_half_pi)) / d_math_half_pi) * (1.0 - center_factor_reduction);
        light_normalized_percentage[e_illuminable_bitmap_side_top] =
          (1.0 - ((radians_incident - (d_math_pi + d_math_half_pi)) / d_math_half_pi)) * (1.0 - center_factor_reduction);
      }
      for (index_side = 0; index_side < e_illuminable_bitmap_side_NULL; ++index_side)
        if ((local_factor =
               (light_normalized_percentage[index_side] * (((lights_emitter->radius - lights_emitter->distance) / lights_emitter->radius) * 255.0))) > 0) {
          /* now we have a factor that is proportional with the angle, with the distance and with the radius of the light. What we should do is to normalized
           * that value using the intensity and the penetration of the light into the  */
          if ((light_final_mask[index_side] += local_factor) > 255.0)
            light_final_mask[index_side] = 255.0;
        }
    }
    for (index_side = 0; index_side < e_illuminable_bitmap_side_NULL; ++index_side) {
      if ((light_final_mask[index_side] > 0) && (illuminable_bitmap_attributes->drawable_mask[index_side])) {
        /* we don't need to check the visibility because, if we are in this function, means that the visibility of the object has been already confirmed by the
         * called */
        d_call(illuminable_bitmap_attributes->drawable_mask[index_side], m_drawable_set_maskRGB, (unsigned int)light_final_mask[index_side],
          (unsigned int)light_final_mask[index_side], (unsigned int)light_final_mask[index_side]);
        while (((intptr_t)d_call(illuminable_bitmap_attributes->drawable_mask[index_side], m_drawable_draw, environment)) == d_drawable_return_continue);
      }
    }
    /* clean the content */
    while ((lights_emitter = (struct s_lights_emitter_description *)(affected_lights.head))) {
      f_list_delete(&(affected_lights), (struct s_list_node *)lights_emitter);
      d_free(lights_emitter);
    }
  }