/**
* @brief This function is called repeatedly.
*
* It checks whether the icon should change.
*/
void ActionIcon::update() {
HudElement::update();
bool need_rebuild = false;
// text shown
if (!is_flipping) {
KeysEffect::ActionKeyEffect action_key_effect = keys_effect->get_action_key_effect();
if (action_key_effect_displayed != action_key_effect) {
// determine the appropriate animation
std::string animation;
if (action_key_effect_displayed != KeysEffect::ACTION_KEY_NONE) {
if (action_key_effect != KeysEffect::ACTION_KEY_NONE) {
animation = "flip";
}
else {
animation = "disappearing";
}
}
else {
animation = "appearing";
}
sprite_action_icon->set_current_animation(animation);
action_key_effect_displayed = action_key_effect;
is_flipping = true;
need_rebuild = true;
}
}
else {
sprite_action_icon->update();
need_rebuild = true;
if (sprite_action_icon->is_animation_finished()) {
is_flipping = false;
}
}
// icon opacity
if (keys_effect->is_action_key_enabled() && get_opacity() == 128) {
set_opacity(255);
}
else if (!keys_effect->is_action_key_enabled() && get_opacity() == 255) {
set_opacity(128);
}
// redraw the surface if something has changed
if (need_rebuild) {
rebuild();
}
}
css_error css__compose_opacity(const css_computed_style *parent,
const css_computed_style *child,
css_computed_style *result)
{
css_fixed opacity = 0;
uint8_t type = get_opacity(child, &opacity);
if (type == CSS_OPACITY_INHERIT) {
type = get_opacity(parent, &opacity);
}
return set_opacity(result, type, opacity);
}
TITANIUM_PROPERTY_GETTER(Animation, opacity)
{
auto opacity = get_opacity();
if (opacity) {
return get_context().CreateNumber(*opacity);
}
return get_context().CreateUndefined();
}
/**
* \brief Apply the intensity and the opacities to a given color.
* \param c The color.
*/
bear::visual::color_type
bear::visual::bitmap_rendering_attributes::convert_color
( const color_type& c ) const
{
return
color_type
( c.components.red * get_red_intensity(),
c.components.green * get_green_intensity(),
c.components.blue * get_blue_intensity(),
c.components.alpha * get_opacity() );
} // bitmap_rendering_attributes::convert_color()
/**
* \brief Gets the intensity of the color channels and the opacity of this
* element, represented by a color instance.
*/
bear::visual::color_type
bear::visual::bitmap_rendering_attributes::get_color() const
{
color_type result;
result.set_red_intensity( get_red_intensity() );
result.set_green_intensity( get_green_intensity() );
result.set_blue_intensity( get_blue_intensity() );
result.set_opacity( get_opacity() );
return result;
} // bitmap_rendering_attributes::get_color()
/**
* \brief Merges the intensity of the color channels and the opacity of the
* element with a given color.
* \param c The color.
*/
void bear::visual::bitmap_rendering_attributes::colorize( color_type c )
{
const color_type::component_type component_max
( std::numeric_limits<color_type::component_type>::max() );
set_intensity
( get_red_intensity() * (double)c.components.red / component_max,
get_green_intensity() * (double)c.components.green / component_max,
get_blue_intensity() * (double)c.components.blue / component_max );
set_opacity( get_opacity() * (double)c.components.alpha / component_max );
} // bitmap_rendering_attributes::colorize()
/**
* \brief Combine with an other set of attributes.
* \param that The attributes to combine with.
*
* The attributes changed by this method are : is_flipped(), is_mirrored(), the
* intensities, the opacity and the angle. The size is not changed.
*/
void bear::visual::bitmap_rendering_attributes::combine
( const bitmap_rendering_attributes& that )
{
flip( that.is_flipped() ^ is_flipped() );
mirror( that.is_mirrored() ^ is_mirrored() );
set_intensity
( that.get_red_intensity() * get_red_intensity(),
that.get_green_intensity() * get_green_intensity(),
that.get_blue_intensity() * get_blue_intensity()
);
set_opacity( that.get_opacity() * get_opacity() );
set_angle( that.get_angle() + get_angle() );
} // bitmap_rendering_attributes::combine()
void AnimatedSprite3D::_draw() {
RID immediate = get_immediate();
VS::get_singleton()->immediate_clear(immediate);
if (!frames.is_valid() || !frames->get_frame_count(animation) || frame<0 || frame>=frames->get_frame_count(animation)) {
return;
}
Ref<Texture> texture = frames->get_frame(animation,frame);
if (!texture.is_valid())
return; //no texuture no life
Vector2 tsize = texture->get_size();
if (tsize.x==0 || tsize.y==0)
return;
Size2i s=tsize;
Rect2i src_rect;
src_rect.size=s;
Point2i ofs=get_offset();
if (is_centered())
ofs-=s/2;
Rect2i dst_rect(ofs,s);
Rect2 final_rect;
Rect2 final_src_rect;
if (!texture->get_rect_region(dst_rect,src_rect,final_rect,final_src_rect))
return;
if (final_rect.size.x==0 || final_rect.size.y==0)
return;
Color color=_get_color_accum();
color.a*=get_opacity();
float pixel_size=get_pixel_size();
Vector2 vertices[4]={
(final_rect.pos+Vector2(0,final_rect.size.y)) * pixel_size,
(final_rect.pos+final_rect.size) * pixel_size,
(final_rect.pos+Vector2(final_rect.size.x,0)) * pixel_size,
final_rect.pos * pixel_size,
};
Vector2 uvs[4]={
final_src_rect.pos / tsize,
(final_src_rect.pos+Vector2(final_src_rect.size.x,0)) / tsize,
(final_src_rect.pos+final_src_rect.size) / tsize,
(final_src_rect.pos+Vector2(0,final_src_rect.size.y)) / tsize,
};
if (is_flipped_h()) {
SWAP(uvs[0],uvs[1]);
SWAP(uvs[2],uvs[3]);
}
if (is_flipped_v()) {
SWAP(uvs[0],uvs[3]);
SWAP(uvs[1],uvs[2]);
}
Vector3 normal;
int axis = get_axis();
normal[axis]=1.0;
RID mat = VS::get_singleton()->material_2d_get(get_draw_flag(FLAG_SHADED),get_draw_flag(FLAG_TRANSPARENT),get_alpha_cut_mode()==ALPHA_CUT_DISCARD,get_alpha_cut_mode()==ALPHA_CUT_OPAQUE_PREPASS);
VS::get_singleton()->immediate_set_material(immediate,mat);
VS::get_singleton()->immediate_begin(immediate,VS::PRIMITIVE_TRIANGLE_FAN,texture->get_rid());
int x_axis = ((axis + 1) % 3);
int y_axis = ((axis + 2) % 3);
if (axis!=Vector3::AXIS_Z) {
SWAP(x_axis,y_axis);
for(int i=0;i<4;i++) {
//uvs[i] = Vector2(1.0,1.0)-uvs[i];
//SWAP(vertices[i].x,vertices[i].y);
if (axis==Vector3::AXIS_Y) {
vertices[i].y = - vertices[i].y;
} else if (axis==Vector3::AXIS_X) {
vertices[i].x = - vertices[i].x;
}
}
}
AABB aabb;
for(int i=0;i<4;i++) {
VS::get_singleton()->immediate_normal(immediate,normal);
VS::get_singleton()->immediate_color(immediate,color);
VS::get_singleton()->immediate_uv(immediate,uvs[i]);
Vector3 vtx;
vtx[x_axis]=vertices[i][0];
vtx[y_axis]=vertices[i][1];
VS::get_singleton()->immediate_vertex(immediate,vtx);
if (i==0) {
aabb.pos=vtx;
aabb.size=Vector3();
} else {
aabb.expand_to(vtx);
}
}
set_aabb(aabb);
VS::get_singleton()->immediate_end(immediate);
}
void Sprite3D::_draw() {
RID immediate = get_immediate();
VS::get_singleton()->immediate_clear(immediate);
if (!texture.is_valid())
return; //no texuture no life
Vector2 tsize = texture->get_size();
if (tsize.x==0 || tsize.y==0)
return;
Size2i s;
Rect2i src_rect;
if (region) {
s=region_rect.size;
src_rect=region_rect;
} else {
s = texture->get_size();
s=s/Size2i(hframes,vframes);
src_rect.size=s;
src_rect.pos.x+=(frame%hframes)*s.x;
src_rect.pos.y+=(frame/hframes)*s.y;
}
Point2i ofs=get_offset();
if (is_centered())
ofs-=s/2;
Rect2i dst_rect(ofs,s);
Rect2 final_rect;
Rect2 final_src_rect;
if (!texture->get_rect_region(dst_rect,src_rect,final_rect,final_src_rect))
return;
if (final_rect.size.x==0 || final_rect.size.y==0)
return;
Color color=_get_color_accum();
color.a*=get_opacity();
float pixel_size=get_pixel_size();
Vector2 vertices[4]={
(final_rect.pos+Vector2(0,final_rect.size.y)) * pixel_size,
(final_rect.pos+final_rect.size) * pixel_size,
(final_rect.pos+Vector2(final_rect.size.x,0)) * pixel_size,
final_rect.pos * pixel_size,
};
Vector2 uvs[4]={
final_src_rect.pos / tsize,
(final_src_rect.pos+Vector2(final_src_rect.size.x,0)) / tsize,
(final_src_rect.pos+final_src_rect.size) / tsize,
(final_src_rect.pos+Vector2(0,final_src_rect.size.y)) / tsize,
};
if (is_flipped_h()) {
SWAP(uvs[0],uvs[1]);
SWAP(uvs[2],uvs[3]);
}
if (is_flipped_v()) {
SWAP(uvs[0],uvs[3]);
SWAP(uvs[1],uvs[2]);
}
Vector3 normal;
int axis = get_axis();
normal[axis]=1.0;
RID mat = VS::get_singleton()->material_2d_get(get_draw_flag(FLAG_SHADED),get_draw_flag(FLAG_TRANSPARENT),get_alpha_cut_mode()==ALPHA_CUT_DISCARD,get_alpha_cut_mode()==ALPHA_CUT_OPAQUE_PREPASS);
VS::get_singleton()->immediate_set_material(immediate,mat);
VS::get_singleton()->immediate_begin(immediate,VS::PRIMITIVE_TRIANGLE_FAN,texture->get_rid());
int x_axis = ((axis + 1) % 3);
int y_axis = ((axis + 2) % 3);
AABB aabb;
for(int i=0;i<4;i++) {
VS::get_singleton()->immediate_normal(immediate,normal);
VS::get_singleton()->immediate_color(immediate,color);
VS::get_singleton()->immediate_uv(immediate,uvs[i]);
Vector3 vtx;
vtx[x_axis]=vertices[i][x_axis];
vtx[y_axis]=vertices[i][y_axis];
VS::get_singleton()->immediate_vertex(immediate,vtx);
if (i==0) {
aabb.pos=vtx;
aabb.size=Vector3();
} else {
aabb.expand_to(vtx);
}
}
set_aabb(aabb);
VS::get_singleton()->immediate_end(immediate);
}
/**
* @brief Updates the item image displayed and the counter's value.
*/
void ItemIcon::update() {
HudElement::update();
bool need_rebuild = false;
KeysEffect &keys_effect = game->get_keys_effect();
// item assigned
const std::string ¤t_item = equipment->get_item_assigned(slot);
if (item_displayed != current_item) {
need_rebuild = true;
item_displayed = current_item;
item_variant_displayed = 0;
if (current_item.size() > 0) {
item_sprite->set_current_animation(current_item);
}
}
if (current_item.size() > 0) {
// variant of the item
int current_item_variant = equipment->get_item_variant(current_item);
if (item_variant_displayed != current_item_variant) {
need_rebuild = true;
item_variant_displayed = current_item_variant;
item_sprite->set_current_direction(current_item_variant - 1);
}
// counter index
int counter_index = equipment->get_item_properties(current_item).get_counter_savegame_variable();
if (counter_index != -1) {
int current_counter_value = equipment->get_item_amount(current_item);
int current_counter_maximum = equipment->get_item_maximum(current_item);
if (counter_value_displayed != current_counter_value || counter_maximum_displayed != current_counter_maximum) {
need_rebuild = true;
counter_maximum_displayed = current_counter_maximum;
counter_value_displayed = current_counter_value;
counter->set_maximum(current_counter_maximum);
counter->set_value(counter_value_displayed);
}
}
else if (counter_value_displayed != -1) {
need_rebuild = true;
counter_value_displayed = -1;
}
}
// icon opacity
if (keys_effect.are_item_keys_enabled() && get_opacity() == 128) {
set_opacity(255);
}
else if (!keys_effect.are_item_keys_enabled() && get_opacity() == 255) {
set_opacity(128);
}
// redraw the icon if needed
if (need_rebuild) {
rebuild();
}
}
void Sprite3D::_draw() {
RID immediate = get_immediate();
VS::get_singleton()->immediate_clear(immediate);
if (!texture.is_valid())
return; //no texuture no life
Vector2 tsize = texture->get_size();
if (tsize.x == 0 || tsize.y == 0)
return;
Size2i s;
Rect2i src_rect;
if (region) {
s = region_rect.size;
src_rect = region_rect;
} else {
s = texture->get_size();
s = s / Size2i(hframes, vframes);
src_rect.size = s;
src_rect.position.x += (frame % hframes) * s.x;
src_rect.position.y += (frame / hframes) * s.y;
}
Point2i ofs = get_offset();
if (is_centered())
ofs -= s / 2;
Rect2i dst_rect(ofs, s);
Rect2 final_rect;
Rect2 final_src_rect;
if (!texture->get_rect_region(dst_rect, src_rect, final_rect, final_src_rect))
return;
if (final_rect.size.x == 0 || final_rect.size.y == 0)
return;
Color color = _get_color_accum();
color.a *= get_opacity();
float pixel_size = get_pixel_size();
Vector2 vertices[4] = {
(final_rect.position + Vector2(0, final_rect.size.y)) * pixel_size,
(final_rect.position + final_rect.size) * pixel_size,
(final_rect.position + Vector2(final_rect.size.x, 0)) * pixel_size,
final_rect.position * pixel_size,
};
Vector2 src_tsize = tsize;
// Properly setup UVs for impostor textures (AtlasTexture).
Ref<AtlasTexture> atlas_tex = texture;
if (atlas_tex != NULL) {
src_tsize[0] = atlas_tex->get_atlas()->get_width();
src_tsize[1] = atlas_tex->get_atlas()->get_height();
}
Vector2 uvs[4] = {
final_src_rect.position / src_tsize,
(final_src_rect.position + Vector2(final_src_rect.size.x, 0)) / src_tsize,
(final_src_rect.position + final_src_rect.size) / src_tsize,
(final_src_rect.position + Vector2(0, final_src_rect.size.y)) / src_tsize,
};
if (is_flipped_h()) {
SWAP(uvs[0], uvs[1]);
SWAP(uvs[2], uvs[3]);
}
if (is_flipped_v()) {
SWAP(uvs[0], uvs[3]);
SWAP(uvs[1], uvs[2]);
}
Vector3 normal;
int axis = get_axis();
normal[axis] = 1.0;
RID mat = SpatialMaterial::get_material_rid_for_2d(get_draw_flag(FLAG_SHADED), get_draw_flag(FLAG_TRANSPARENT), get_draw_flag(FLAG_DOUBLE_SIDED), get_alpha_cut_mode() == ALPHA_CUT_DISCARD, get_alpha_cut_mode() == ALPHA_CUT_OPAQUE_PREPASS);
VS::get_singleton()->immediate_set_material(immediate, mat);
VS::get_singleton()->immediate_begin(immediate, VS::PRIMITIVE_TRIANGLE_FAN, texture->get_rid());
int x_axis = ((axis + 1) % 3);
int y_axis = ((axis + 2) % 3);
if (axis != Vector3::AXIS_Z) {
SWAP(x_axis, y_axis);
for (int i = 0; i < 4; i++) {
//uvs[i] = Vector2(1.0,1.0)-uvs[i];
//SWAP(vertices[i].x,vertices[i].y);
if (axis == Vector3::AXIS_Y) {
vertices[i].y = -vertices[i].y;
} else if (axis == Vector3::AXIS_X) {
vertices[i].x = -vertices[i].x;
}
}
}
AABB aabb;
for (int i = 0; i < 4; i++) {
VS::get_singleton()->immediate_normal(immediate, normal);
VS::get_singleton()->immediate_color(immediate, color);
VS::get_singleton()->immediate_uv(immediate, uvs[i]);
Vector3 vtx;
vtx[x_axis] = vertices[i][0];
vtx[y_axis] = vertices[i][1];
VS::get_singleton()->immediate_vertex(immediate, vtx);
if (i == 0) {
aabb.position = vtx;
aabb.size = Vector3();
} else {
aabb.expand_to(vtx);
}
}
set_aabb(aabb);
VS::get_singleton()->immediate_end(immediate);
}
/**
* \brief Tell if the sprite has a transparency.
*/
bool bear::visual::sprite::has_transparency() const
{
return (get_opacity() != 1) || m_image.has_transparency();
} // sprite::has_transparency()
