void ScaleSelected::visit(const scene::INodePtr& node) const {
ITransformNodePtr transformNode = Node_getTransformNode(node);
if(transformNode != 0)
{
ITransformablePtr transform = Node_getTransformable(node);
if(transform != 0)
{
transform->setType(TRANSFORM_PRIMITIVE);
transform->setScale(c_scale_identity);
transform->setTranslation(c_translation_identity);
transform->setType(TRANSFORM_PRIMITIVE);
transform->setScale(m_scale);
{
EditablePtr editable = Node_getEditable(node);
const Matrix4& localPivot = editable != 0 ? editable->getLocalPivot() : Matrix4::getIdentity();
Vector3 parent_translation;
translation_for_pivoted_scale(
parent_translation,
m_scale,
m_world_pivot,
node->localToWorld().getMultipliedBy(localPivot),
transformNode->localToParent().getMultipliedBy(localPivot)
);
transform->setTranslation(parent_translation);
}
}
}
}
void RotateSelected::visit(const scene::INodePtr& node) const
{
ITransformNodePtr transformNode = Node_getTransformNode(node);
if (transformNode)
{
// Upcast the instance onto a Transformable
ITransformablePtr transformable = Node_getTransformable(node);
if (transformable)
{
// The object is not scaled or translated explicitly
// A translation might occur due to the rotation around a pivot point
transformable->setType(TRANSFORM_PRIMITIVE);
transformable->setScale(c_scale_identity);
transformable->setTranslation(c_translation_identity);
// Pass the rotation quaternion and the world pivot,
// unless we're rotating each object around their own center
transformable->setRotation(_rotation,
_freeObjectRotation ? transformable->getUntransformedOrigin() : _worldPivot,
node->localToWorld());
}
}
}
void TranslateSelected::visit(const scene::INodePtr& node) const {
ITransformablePtr transform = Node_getTransformable(node);
if(transform != 0) {
transform->setType(TRANSFORM_PRIMITIVE);
transform->setTranslation(m_translate);
}
}
void TranslateComponentSelected::visit(const scene::INodePtr& node) const {
ITransformablePtr transform = Node_getTransformable(node);
if(transform != 0)
{
transform->setType(TRANSFORM_COMPONENT);
transform->setTranslation(m_translate);
}
}
void ScaleComponentSelected::visit(const scene::INodePtr& node) const {
ITransformablePtr transform = Node_getTransformable(node);
if(transform != 0) {
Vector3 parent_translation;
translation_for_pivoted_scale(parent_translation, m_scale, m_world_pivot, node->localToWorld(), Node_getTransformNode(node)->localToParent());
transform->setType(TRANSFORM_COMPONENT);
transform->setScale(m_scale);
transform->setTranslation(parent_translation);
}
}
/**
* greebo: Creates a new entity with an attached curve
*
* @key: The curve type: pass either "curve_CatmullRomSpline" or "curve_Nurbs".
*/
void createCurve(const std::string& key)
{
UndoableCommand undo(std::string("createCurve: ") + key);
// De-select everything before we proceed
GlobalSelectionSystem().setSelectedAll(false);
GlobalSelectionSystem().setSelectedAllComponents(false);
std::string curveEClass = game::current::getValue<std::string>(GKEY_DEFAULT_CURVE_ENTITY);
// Fallback to func_static, if nothing defined in the registry
if (curveEClass.empty()) {
curveEClass = "func_static";
}
// Find the default curve entity
IEntityClassPtr entityClass = GlobalEntityClassManager().findOrInsert(
curveEClass,
true
);
// Create a new entity node deriving from this entityclass
IEntityNodePtr curve(GlobalEntityCreator().createEntity(entityClass));
// Insert this new node into the scenegraph root
GlobalSceneGraph().root()->addChildNode(curve);
// Select this new curve node
Node_setSelected(curve, true);
// Set the model key to be the same as the name
curve->getEntity().setKeyValue("model",
curve->getEntity().getKeyValue("name"));
// Initialise the curve using three pre-defined points
curve->getEntity().setKeyValue(
key,
"3 ( 0 0 0 50 50 0 50 100 0 )"
);
ITransformablePtr transformable = Node_getTransformable(curve);
if (transformable != NULL) {
// Translate the entity to the center of the current workzone
transformable->setTranslation(GlobalXYWnd().getActiveXY()->getOrigin());
transformable->freezeTransform();
}
}
/**
* Create an instance of the given entity at the given position, and return
* the Node containing the new entity.
*
* @returns: the scene::INodePtr referring to the new entity.
*/
scene::INodePtr createEntityFromSelection(const std::string& name, const Vector3& origin)
{
// Obtain the structure containing the selection counts
const SelectionInfo& info = GlobalSelectionSystem().getSelectionInfo();
IEntityClassPtr entityClass = GlobalEntityClassManager().findOrInsert(name, true);
// TODO: to be replaced by inheritance-based class detection
bool isModel = (info.totalCount == 0 && name == "func_static");
// Some entities are based on the size of the currently-selected primitive(s)
bool primitivesSelected = info.brushCount > 0 || info.patchCount > 0;
if (!(entityClass->isFixedSize() || isModel) && !primitivesSelected) {
throw EntityCreationException(
(boost::format(_("Unable to create entity %s, no brushes selected.")) % name).str()
);
}
// Get the selection workzone bounds
AABB workzone = GlobalSelectionSystem().getWorkZone().bounds;
// Create the new node for the entity
IEntityNodePtr node(GlobalEntityCreator().createEntity(entityClass));
GlobalSceneGraph().root()->addChildNode(node);
// The layer list we're moving the newly created node/subgraph into
scene::LayerList targetLayers;
if (entityClass->isFixedSize() || (isModel && !primitivesSelected))
{
selection::algorithm::deleteSelection();
ITransformablePtr transform = Node_getTransformable(node);
if (transform != 0) {
transform->setType(TRANSFORM_PRIMITIVE);
transform->setTranslation(origin);
transform->freezeTransform();
}
GlobalSelectionSystem().setSelectedAll(false);
// Move the item to the active layer
targetLayers.insert(GlobalLayerSystem().getActiveLayer());
Node_setSelected(node, true);
}
else // brush-based entity
{
// Add selected brushes as children of non-fixed entity
node->getEntity().setKeyValue("model",
node->getEntity().getKeyValue("name"));
// Take the selection center as new origin
Vector3 newOrigin = selection::algorithm::getCurrentSelectionCenter();
node->getEntity().setKeyValue("origin", string::to_string(newOrigin));
// If there is an "editor_material" class attribute, apply this shader
// to all of the selected primitives before parenting them
std::string material = node->getEntity().getEntityClass()->getAttribute("editor_material").getValue();
if (!material.empty()) {
selection::algorithm::applyShaderToSelection(material);
}
// If we had primitives to reparent, the new entity should inherit the layer info from them
if (primitivesSelected)
{
scene::INodePtr primitive = GlobalSelectionSystem().ultimateSelected();
targetLayers = primitive->getLayers();
}
else
{
// Otherwise move the item to the active layer
targetLayers.insert(GlobalLayerSystem().getActiveLayer());
}
// Parent the selected primitives to the new node
selection::algorithm::ParentPrimitivesToEntityWalker walker(node);
GlobalSelectionSystem().foreachSelected(walker);
walker.reparent();
// De-select the children and select the newly created parent entity
GlobalSelectionSystem().setSelectedAll(false);
Node_setSelected(node, true);
}
// Assign the layers - including all child nodes (#2864)
scene::AssignNodeToLayersWalker layerWalker(targetLayers);
Node_traverseSubgraph(node, layerWalker);
// Set the light radius and origin
if (entityClass->isLight() && primitivesSelected)
{
AABB bounds(Doom3Light_getBounds(workzone));
node->getEntity().setKeyValue("origin",
string::to_string(bounds.getOrigin()));
node->getEntity().setKeyValue("light_radius",
string::to_string(bounds.getExtents()));
}
// Flag the map as unsaved after creating the entity
GlobalMap().setModified(true);
// Check for auto-setting key values. TODO: use forEachClassAttribute
// directly here.
eclass::AttributeList list = eclass::getSpawnargsWithPrefix(
*entityClass, "editor_setKeyValue"
);
if (!list.empty())
{
for (eclass::AttributeList::const_iterator i = list.begin(); i != list.end(); ++i)
{
// Cut off the "editor_setKeyValueN " string from the key to get the spawnarg name
std::string key = i->getName().substr(i->getName().find_first_of(' ') + 1);
node->getEntity().setKeyValue(key, i->getValue());
}
}
// Return the new node
return node;
}
