Technique for allowing blendings of StaticModels?

Hello,
I have a ‘beam’ that is a scaled StaticModel cylinder and a weapon whose bullet is a StaticModel too.
What material Technique may i use to blend these two together?

grokko

it isn’t clear what you want to achieve. May I ask you for a simple sketch or reference image?

Hi,
Sorry if my question wasn’t clear…

How can I blend two StaticModels together?

I have a LogicComponent which shoots a queue of StaticModel Nodes into the space. They’re load balanced so they
shoot and perform really well…but sometimes when I launch a flurry of shots in the space, and then turn a couple of degrees and launch more…the bullet Nodes hit each other and explode
on each other,

I’m kinda new to the great Urho so I suppose such a device of blending might be a technique?

Mike

Sounds like you have physics issue. You have to move bullet colliders to a separate layer and disable collisions with the same layer. This way bullets won’t collide with eachother only with non-bullet objects.

You have to move bullet colliders to a separate layer and disable collisions with the same layer.

Hi,
Thanks for helping! You mean like this…?

bd->SetCollisionLayer(1);
bd->SetCollisionEventMode(COLLISION_NEVER);

wherein ‘bd’ is a RigidBody pointer.

I tried a couple combinations, still nothing…

Mike

// for bullets
body->SetCollisionLayer(0x01);
body->SetCollisionMask(0x10);

// for targets
body->SetCollisionLayer(0x10);
body->SetCollisionMask(0x01);

You can use this layer and mask patten to avoid collision btw bullets.

so the layer is also a bitmask?

Yes. It’s super easy to use, too. Here’s a header file for dealing with collision layers that I used in a project recently:

#pragma once

// Collision layers and masks are &'ed together to determine if a collision event should occur.

namespace CollisionLayer
{
    static const unsigned int None = 0;
    static const unsigned int Controllable = 1 << 0;
    static const unsigned int Static = 1 << 1;
    static const unsigned int Platform = 1 << 2;
    static const unsigned int Projectile = 1 << 3;
    static const unsigned int All = -1;
}

namespace CollisionMask
{
    static const unsigned int None = CollisionLayer::None;
    static const unsigned int Controllable = CollisionLayer::Static | CollisionLayer::Platform | CollisionLayer::Projectile;
    static const unsigned int Static = CollisionLayer::Controllable | CollisionLayer::Projectile;
    static const unsigned int Platform = CollisionLayer::Controllable | CollisionLayer::Projectile;
    static const unsigned int Projectile = CollisionLayer::Controllable | CollisionLayer::Static | CollisionLayer::Platform;
    static const unsigned int All = CollisionLayer::All;
}

The CollisionLayer values are passed as the Layer, and the CollisionMask values are passed as the Mask. In a sense, the Layer is what the thing is and the Mask is what the thing collides with . In the above example we say our Controllable types (the player) can collide with Static/Platform/Projectile, and that our Projectile types can collide with Controllable/Static/Platform. Projectiles will not collide with other Projectiles as it is currently configured, but you can easily change that by using

static const unsigned int Projectile = CollisionLayer::Controllable | CollisionLayer::Static | CollisionLayer::Platform | CollisionLayer::Projectile;

To use this, you just set the Layer and Mask of each object to their corresponding values:

auto characterBody = characterNode->CreateComponent<RigidBody>();
characterBody->SetCollisionLayerAndMask(CollisionLayer::Controllable, CollisionMask::Controllable);

auto floorBody = floorNode->CreateComponent<RigidBody>();
floorBody->SetCollisionLayerAndMask(CollisionLayer::Platform, CollisionMask::Platform);

auto missileBody = missileNode->CreateComponent<RigidBody>();
missileBody->SetCollisionLayerAndMask(CollisionLayer::Projectile, CollisionMask::Projectile);

The SetCollisionLayerAndMask() calls become trivial, and I find the collision logic is easier to configure. It’s also easy to add more Layers and Masks.

I just though that layer is a bit index, not a bitmask itself. Good to know before I spent hours debugging it