Arma3_Epoch/ACE3
1
0
Fork 0
mirror of https://github.com/acemod/ACE3.git synced 2024-08-30 18:23:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Animations nearly aligning correctly.

Browse Source
This commit is contained in:
jaynus 2015-05-11 22:33:39 -07:00
parent ac1ae6c596
commit 77614ca015
14 changed files with 362 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
addons/vehicledamage/functions/fnc_getAnimationStates.sqf
View File

@ -35,7 +35,7 @@ if(_sendToExtension) then {
_cmd = "set_animation_state:";
{
_cmd = _cmd + format["%1,%2,", (_x select 0), (_x select 1)];
_cmd = _cmd + format["%1,%2,", (_x select 0), ([(_x select 1)] call CBA_fnc_formatNumber)];
} forEach _animationResults;
_cmd call FUNC(callExtension);

2
addons/vehicledamage/script_component.hpp
View File

@ -18,4 +18,4 @@
#define DEBUG_EXTENSION_DYNLOAD
#define DEBUG_LOG_EXTENSION
//#define DEBUG_EXTENSION_DYNLOAD_RELOAD
#define DEBUG_VEHICLEDAMAGE_RENDER
//#define DEBUG_VEHICLEDAMAGE_RENDER

3
extensions/common/arguments.hpp
View File

@ -40,6 +40,9 @@ namespace ace {
public:
arguments(const std::string & str) : _original(str) {
_args = ace::split(str, ',');
for (int i = 0; i < _args.size(); i++) {
_args[i] = trim(_args[i]);
}
}
size_t size() const { return _args.size(); }

5
extensions/common/shared.cpp
View File

@ -1,5 +1,10 @@
#include "shared.hpp"
#include <algorithm>
#include <functional>
#include <cctype>
#include <locale>
int test(int var) {
return var;
}

17
extensions/common/shared.hpp
View File

@ -40,6 +40,23 @@ namespace ace {
std::vector<std::string> &split(const std::string &s, char delim, std::vector<std::string> &elems);
std::vector<std::string> split(const std::string &s, char delim);
// trim from start
static inline std::string &ltrim(std::string &s) {
s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
return s;
}
// trim from end
static inline std::string &rtrim(std::string &s) {
s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
return s;
}
// trim from both ends
static inline std::string &trim(std::string &s) {
return ltrim(rtrim(s));
}
inline void runtime_assert(bool result);
struct exception {

601
extensions/common/simulation/object.cpp
View File

@ -6,8 +6,8 @@
ace::simulation::vertex::vertex(vertex_table & _table, ace::vector3<float> _vertex, uint32_t _id) : table(_table), vertex_id(_id)
{
this->original_vertex = _vertex;
this->animated_vertex = _vertex;
this->original_vertex = _vertex;
this->animated_vertex = _vertex;
}
ace::simulation::vertex::~vertex()
@ -16,16 +16,16 @@ ace::simulation::vertex::~vertex()
ace::simulation::face::face(
const ace::p3d::face_p p3d_face,
const ace::p3d::lod_p p3d_lod,
const ace::p3d::model_p p3d,
ace::simulation::lod *object_lod)
const ace::p3d::face_p p3d_face,
const ace::p3d::lod_p p3d_lod,
const ace::p3d::model_p p3d,
ace::simulation::lod *object_lod)
{
this->type = p3d_face->type;
for (uint16_t vertex_id : p3d_face->vertex_table) {
this->vertices.push_back(object_lod->vertices[vertex_id]);
object_lod->vertices[vertex_id]->faces.push_back(this);
}
this->type = p3d_face->type;
for (uint16_t vertex_id : p3d_face->vertex_table) {
this->vertices.push_back(object_lod->vertices[vertex_id]);
object_lod->vertices[vertex_id]->faces.push_back(this);
}
}
ace::simulation::face::~face()
@ -34,32 +34,32 @@ ace::simulation::face::~face()
void ace::simulation::vertex::animate(const glm::mat4 &matrix, ace::vector3<float> rotation_offset, bool offset)
{
ace::vector3<float> temp_vector = this->original_vertex;
if (offset) {
temp_vector = temp_vector - rotation_offset;
}
glm::vec4 temp_gl_vector = glm::vec4(temp_vector.x(), temp_vector.y(), temp_vector.z(), 1.0f);
temp_gl_vector = matrix*temp_gl_vector;
this->animated_vertex = ace::vector3<float>(temp_gl_vector.x, temp_gl_vector.y, temp_gl_vector.z);
if (offset) {
// this->animated_vertex = this->animated_vertex + rotation_offset;
}
ace::vector3<float> temp_vector = this->original_vertex;
if (offset) {
temp_vector = temp_vector - rotation_offset;
}
glm::vec4 temp_gl_vector = glm::vec4(temp_vector.x(), temp_vector.y(), temp_vector.z(), 1.0f);
temp_gl_vector = matrix*temp_gl_vector;
this->animated_vertex = ace::vector3<float>(temp_gl_vector.x, temp_gl_vector.y, temp_gl_vector.z);
if (offset) {
// this->animated_vertex = this->animated_vertex + rotation_offset;
}
}
ace::simulation::named_selection::named_selection(
const ace::p3d::named_selection_p p3d_selection,
const ace::p3d::lod_p p3d_lod,
const ace::p3d::model_p p3d,
ace::simulation::lod *object_lod)
const ace::p3d::named_selection_p p3d_selection,
const ace::p3d::lod_p p3d_lod,
const ace::p3d::model_p p3d,
ace::simulation::lod *object_lod)
{
this->name = p3d_selection->name;
for (uint16_t vertex_id : p3d_selection->vertex_table.data) {
this->vertices.push_back(object_lod->vertices[vertex_id]);
object_lod->vertices[vertex_id]->selections.push_back(this);
}
for (uint16_t face_id : p3d_selection->faces.data) {
this->faces.push_back(object_lod->faces[face_id]);
}
this->name = p3d_selection->name;
for (uint16_t vertex_id : p3d_selection->vertex_table.data) {
this->vertices.push_back(object_lod->vertices[vertex_id]);
object_lod->vertices[vertex_id]->selections.push_back(this);
}
for (uint16_t face_id : p3d_selection->faces.data) {
this->faces.push_back(object_lod->faces[face_id]);
}
}
ace::simulation::named_selection::~named_selection()
@ -68,10 +68,10 @@ ace::simulation::named_selection::~named_selection()
void ace::simulation::named_selection::animate(const glm::mat4 &matrix, ace::vector3<float> rotation_offset)
{
bool offset = !rotation_offset.zero_distance();
for (auto selection_vertex : this->vertices) {
selection_vertex->animate(matrix, rotation_offset, offset);
}
bool offset = !rotation_offset.zero_distance();
for (auto selection_vertex : this->vertices) {
selection_vertex->animate(matrix, rotation_offset, offset);
}
}
@ -79,21 +79,21 @@ void ace::simulation::named_selection::animate(const glm::mat4 &matrix, ace::vec
ace::simulation::vertex_table::vertex_table(const ace::p3d::vertex_table_p p3d_vertex_table, const ace::p3d::lod_p p3d_lod, const ace::p3d::model_p p3d) : animated(false)
{
this->vertices.resize(p3d_vertex_table->points.size);
for (uint32_t i = 0; i <= p3d_vertex_table->points.size - 1; ++i) {
if(p3d->info->autocenter) {
ace::vector3<float> new_vertex = ace::vector3<float>(
p3d_vertex_table->points[i].x() + (p3d_lod->autocenter_pos.x()*-1),
p3d_vertex_table->points[i].y() + (p3d_lod->autocenter_pos.y()*-1),
p3d_vertex_table->points[i].z() + (p3d_lod->autocenter_pos.z()*-1)
);
this->vertices[i] = std::make_shared<vertex>(*this, new_vertex, i);
this->vertices.resize(p3d_vertex_table->points.size);
for (uint32_t i = 0; i <= p3d_vertex_table->points.size - 1; ++i) {
if (p3d->info->autocenter) {
ace::vector3<float> new_vertex = ace::vector3<float>(
p3d_vertex_table->points[i].x() + (p3d_lod->autocenter_pos.x()*-1),
p3d_vertex_table->points[i].y() + (p3d_lod->autocenter_pos.y()*-1),
p3d_vertex_table->points[i].z() + (p3d_lod->autocenter_pos.z()*-1)
);
this->vertices[i] = std::make_shared<vertex>(*this, new_vertex, i);
}
else {
this->vertices[i] = std::make_shared<vertex>(*this, p3d_vertex_table->points[i], i);
}
}
}
else {
this->vertices[i] = std::make_shared<vertex>(*this, p3d_vertex_table->points[i], i);
}
}
}
ace::simulation::vertex_table::~vertex_table()
@ -102,17 +102,17 @@ ace::simulation::vertex_table::~vertex_table()
ace::simulation::lod::lod(const ace::p3d::lod_p p3d_lod, const ace::p3d::model_p p3d)
{
this->id = p3d_lod->id;
this->vertices = vertex_table(p3d_lod->vertices, p3d_lod, p3d);
this->autocenter_pos = p3d_lod->autocenter_pos;
this->id = p3d_lod->id;
this->vertices = vertex_table(p3d_lod->vertices, p3d_lod, p3d);
this->autocenter_pos = p3d_lod->autocenter_pos;
for (ace::p3d::face_p p3d_face : p3d_lod->faces) {
this->faces.push_back(std::make_shared<face>(p3d_face, p3d_lod, p3d, this));
}
for (ace::p3d::face_p p3d_face : p3d_lod->faces) {
this->faces.push_back(std::make_shared<face>(p3d_face, p3d_lod, p3d, this));
}
for (ace::p3d::named_selection_p p3d_selection : p3d_lod->selections) {
this->selections[p3d_selection->name] = std::make_shared<named_selection>(p3d_selection, p3d_lod, p3d, this);
}
for (ace::p3d::named_selection_p p3d_selection : p3d_lod->selections) {
this->selections[p3d_selection->name] = std::make_shared<named_selection>(p3d_selection, p3d_lod, p3d, this);
}
}
@ -121,21 +121,21 @@ ace::simulation::lod::~lod()
}
ace::simulation::lod_animation_info::lod_animation_info(
animation *_animation,
lod_p _lod,
const ace::p3d::animate_bone_p p3d_animate_bone,
const ace::p3d::animation_p p3d_animation,
const ace::p3d::model_p p3d) : animation_definition(_animation), lod(_lod)
animation *_animation,
lod_p _lod,
const ace::p3d::animate_bone_p p3d_animate_bone,
const ace::p3d::animation_p p3d_animation,
const ace::p3d::model_p p3d) : animation_definition(_animation), lod(_lod)
{
this->index = p3d_animate_bone->index;
if (p3d->info->autocenter) {
this->axis_position = p3d_animate_bone->axis_position + (lod->autocenter_pos*-1);
this->axis_direction = p3d_animate_bone->axis_direction.normalize();
}
else {
this->axis_position = p3d_animate_bone->axis_position;
this->axis_direction = p3d_animate_bone->axis_direction.normalize();
}
this->index = p3d_animate_bone->index;
if (p3d->info->autocenter) {
this->axis_position = p3d_animate_bone->axis_position + (lod->autocenter_pos*-1);
this->axis_direction = p3d_animate_bone->axis_direction.normalize();
}
else {
this->axis_position = p3d_animate_bone->axis_position;
this->axis_direction = p3d_animate_bone->axis_direction.normalize();
}
}
ace::simulation::lod_animation_info::~lod_animation_info()
@ -144,54 +144,54 @@ ace::simulation::lod_animation_info::~lod_animation_info()
ace::simulation::animation::animation(object *parent_object, const ace::p3d::animation_p p3d_animation, const ace::p3d::model_p p3d)
{
this->type = p3d_animation->type;
this->name = p3d_animation->name;
this->source = p3d_animation->source;
this->type = p3d_animation->type;
this->name = p3d_animation->name;
this->source = p3d_animation->source;
this->source_address = p3d_animation->source_address;
this->source_address = p3d_animation->source_address;
this->min_value = p3d_animation->min_value;
this->max_value = p3d_animation->max_value;
this->min_value = p3d_animation->min_value;
this->max_value = p3d_animation->max_value;
this->min_phase = p3d_animation->min_phase;
this->max_phase = p3d_animation->max_phase;
this->min_phase = p3d_animation->min_phase;
this->max_phase = p3d_animation->max_phase;
switch (type) {
// rotations
case 0:
case 1:
case 2:
case 3:
angle0 = p3d_animation->angle0;
angle1 = p3d_animation->angle1;
break;
// translations
case 4:
case 5:
case 6:
case 7:
offset0 = p3d_animation->offset0;
offset1 = p3d_animation->offset1;
break;
case 8:
direct_axis_pos = p3d_animation->direct_axis_pos;
direct_axis_dir = p3d_animation->direct_axis_dir;
direct_angle = p3d_animation->direct_angle;
direct_axis_offset = p3d_animation->direct_axis_offset;
break;
case 9:
hide_value = p3d_animation->hide_value;
default:
offset0 = 0.0f;
offset1 = 0.0f;
}
switch (type) {
// rotations
case 0:
case 1:
case 2:
case 3:
angle0 = p3d_animation->angle0;
angle1 = p3d_animation->angle1;
break;
// translations
case 4:
case 5:
case 6:
case 7:
offset0 = p3d_animation->offset0;
offset1 = p3d_animation->offset1;
break;
case 8:
direct_axis_pos = p3d_animation->direct_axis_pos;
direct_axis_dir = p3d_animation->direct_axis_dir;
direct_angle = p3d_animation->direct_angle;
direct_axis_offset = p3d_animation->direct_axis_offset;
break;
case 9:
hide_value = p3d_animation->hide_value;
default:
offset0 = 0.0f;
offset1 = 0.0f;
}
for (ace::p3d::animate_bone_p animation_bone : p3d_animation->bones) {
this->lod_info[animation_bone->lod] = std::make_shared<lod_animation_info>(this, parent_object->lods[animation_bone->lod], animation_bone, p3d_animation, p3d);
}
for (ace::p3d::animate_bone_p animation_bone : p3d_animation->bones) {
this->lod_info[animation_bone->lod] = std::make_shared<lod_animation_info>(this, parent_object->lods[animation_bone->lod], animation_bone, p3d_animation, p3d);
}
}
@ -200,10 +200,10 @@ ace::simulation::animation::~animation()
}
typedef union {
float f;
struct {
uint32_t sh1 : 32;
} parts;
float f;
struct {
uint32_t sh1 : 32;
} parts;
} double_cast;
#define RAD2DEG(rad) (rad * 180.0f / 3.1415926f);
@ -211,176 +211,197 @@ typedef union {
typedef std::map<uint32_t, std::pair<glm::mat4, ace::vector3<float>>> animation_transform;
animation_transform ace::simulation::animation::animate(const float phase, const std::vector<uint32_t> &lods, animation_transform base_transforms)
{
animation_transform return_matrices;
for (auto lod_id : lods) {
glm::mat4 base_matrix = base_transforms[lod_id].first;
ace::vector3<float> base_rotation_offset = base_transforms[lod_id].second;
glm::mat4 animation_matrix, direction_matrix;
ace::vector3<float> rotation_offset = ace::vector3<float>(0, 0, 0);
animation_transform return_matrices;
for (auto lod_id : lods) {
glm::mat4 base_matrix = base_transforms[lod_id].first;
ace::vector3<float> base_rotation_offset = base_transforms[lod_id].second;
glm::mat4 animation_matrix, direction_matrix;
ace::vector3<float> rotation_offset = ace::vector3<float>(0, 0, 0);
float scale = get_scale(phase);
float scale = get_scale(phase);
switch (this->type) {
//rotation
case 0: {
scale = (scale / (max_value - min_value)) * (angle1 - angle0);
glm::vec3 rotation_axis = glm::vec3(this->lod_info[lod_id]->axis_position.x(), this->lod_info[lod_id]->axis_position.y(), this->lod_info[lod_id]->axis_position.z());
glm::vec3 rotation_direction = glm::vec3(this->lod_info[lod_id]->axis_direction.x(), this->lod_info[lod_id]->axis_direction.y(), this->lod_info[lod_id]->axis_direction.z());
glm::vec3 axis_position = glm::vec3(this->lod_info[lod_id]->axis_position.x(), this->lod_info[lod_id]->axis_position.y(), this->lod_info[lod_id]->axis_position.z());
glm::vec3 axis_direction = glm::vec3(this->lod_info[lod_id]->axis_direction.x(), this->lod_info[lod_id]->axis_direction.y(), this->lod_info[lod_id]->axis_direction.z());
animation_matrix = glm::rotate(glm::mat4(1.0f), scale, rotation_direction);
direction_matrix = glm::translate(glm::mat4(1.0f), rotation_axis);
animation_matrix = animation_matrix * direction_matrix;
if (true) {
switch (this->type) {
//rotation
case 0: {
scale = (scale / (max_value - min_value)) * (angle1 - angle0);
rotation_offset = this->lod_info[lod_id]->axis_position;
break;
}
//rotationX
case 1: {
scale = (scale / (max_value - min_value)) * (angle1 - angle0);
glm::vec3 rotation_axis = glm::vec3(1.0f, 0.0f, 0.0f);
animation_matrix = glm::rotate(animation_matrix, scale, rotation_axis);
rotation_offset = this->lod_info[lod_id]->axis_position;
break;
}
//rotationY
case 2: {
scale = (scale / (max_value - min_value)) * (angle1 - angle0);
glm::vec3 rotation_axis = glm::vec3(0.0f, 1.0f, 0.0f);
animation_matrix = glm::rotate(animation_matrix, scale, rotation_axis);
rotation_offset = this->lod_info[lod_id]->axis_position;
break;
}
//rotationZ
case 3: {
scale = (scale / (max_value - min_value)) * (angle1 - angle0);
glm::vec3 rotation_axis = glm::vec3(0.0f, 0.0f, 1.0f);
animation_matrix = glm::rotate(animation_matrix, scale, rotation_axis);
rotation_offset = this->lod_info[lod_id]->axis_position;
break;
}
//translation
case 4: {
scale = (scale / (max_value - min_value)) * (offset1 - offset0);
animation_matrix = glm::translate(animation_matrix, glm::vec3(
this->lod_info[lod_id]->axis_direction.x()*scale,
this->lod_info[lod_id]->axis_direction.y()*scale,
this->lod_info[lod_id]->axis_direction.z()*scale
));
animation_matrix = glm::rotate(glm::mat4(1.0f), scale, axis_direction);
direction_matrix = glm::translate(glm::mat4(1.0f), axis_position);
break;
}
//translationX
case 5: {
animation_matrix = glm::translate(animation_matrix, glm::vec3(
scale,
0.0f,
0.0f
));
break;
}
//translationY
case 6: {
animation_matrix = glm::translate(animation_matrix, glm::vec3(
0.0f,
scale,
0.0f
));
break;
}
//translationZ
case 7: {
animation_matrix = glm::translate(animation_matrix, glm::vec3(
0.0f,
0.0f,
scale
));
break;
}
case 8: {
// fuck direct for now
}
//hide
case 9: {
if(phase >= hide_value)
animation_matrix = glm::mat4x4(0.0f);
break;
}
default: {}
}
return_matrices[lod_id].first = animation_matrix * base_matrix;
return_matrices[lod_id].second = base_rotation_offset + rotation_offset;
}
return return_matrices;
animation_matrix = animation_matrix * direction_matrix;
rotation_offset = this->lod_info[lod_id]->axis_position;
break;
}
//rotationX
case 1: {
scale = (scale / (max_value - min_value)) * (angle1 - angle0);
glm::vec3 rotation_axis = glm::vec3(1.0f, 0.0f, 0.0f);
animation_matrix = glm::rotate(glm::mat4(1.0f), scale, rotation_axis);
direction_matrix = glm::translate(glm::mat4(1.0f), axis_position);
animation_matrix = animation_matrix * direction_matrix;
rotation_offset = this->lod_info[lod_id]->axis_position;
break;
}
//rotationY
case 2: {
scale = (scale / (max_value - min_value)) * (angle1 - angle0);
glm::vec3 rotation_axis = glm::vec3(0.0f, 1.0f, 0.0f);
animation_matrix = glm::rotate(glm::mat4(1.0f), scale, rotation_axis);
direction_matrix = glm::translate(glm::mat4(1.0f), axis_position);
animation_matrix = animation_matrix * direction_matrix;
rotation_offset = this->lod_info[lod_id]->axis_position;
break;
}
//rotationZ
case 3: {
scale = (scale / (max_value - min_value)) * (angle1 - angle0);
glm::vec3 rotation_axis = glm::vec3(0.0f, 0.0f, 1.0f);
animation_matrix = glm::rotate(glm::mat4(1.0f), scale, rotation_axis);
direction_matrix = glm::translate(glm::mat4(1.0f), axis_position);
animation_matrix = animation_matrix * direction_matrix;
rotation_offset = this->lod_info[lod_id]->axis_position;
break;
}
//translation
case 4: {
scale = (scale / (max_value - min_value)) * (offset1 - offset0);
animation_matrix = glm::translate(glm::mat4(1.0f), glm::vec3(
this->lod_info[lod_id]->axis_direction.x()*scale,
this->lod_info[lod_id]->axis_direction.y()*scale,
this->lod_info[lod_id]->axis_direction.z()*scale
));
break;
}
//translationX
case 5: {
scale = (scale / (max_value - min_value)) * (offset1 - offset0);
animation_matrix = glm::translate(animation_matrix, glm::vec3(
scale,
0.0f,
0.0f
));
break;
}
//translationY
case 6: {
scale = (scale / (max_value - min_value)) * (offset1 - offset0);
animation_matrix = glm::translate(animation_matrix, glm::vec3(
0.0f,
scale,
0.0f
));
break;
}
//translationZ
case 7: {
scale = (scale / (max_value - min_value)) * (offset1 - offset0);
animation_matrix = glm::translate(animation_matrix, glm::vec3(
0.0f,
0.0f,
scale
));
break;
}
case 8: {
// fuck direct for now
}
//hide
case 9: {
if (phase >= hide_value)
animation_matrix = glm::mat4x4(0.0f);
break;
}
default: {}
}
return_matrices[lod_id].first = animation_matrix * base_matrix;
return_matrices[lod_id].second = base_rotation_offset + rotation_offset;
}
}
return return_matrices;
}
float ace::simulation::animation::get_scale(float phase)
{
float scale = 0;
float scale = 0;
switch (source_address)
{
case 1:
scale = fmod(phase - min_value, max_value - min_value) + min_value;
scale = std::min(std::max(scale, min_phase), max_phase);
break;
case 2:
scale = fmod(phase - min_value, (max_value - min_value) * 2) + min_value;
if (scale > max_value) scale = max_value - (scale - max_value);
scale = std::min(std::max(scale, min_phase), max_phase);
break;
default:
scale = std::min(std::max(phase, min_phase), max_phase);
}
switch (source_address)
{
case 1:
scale = fmod(phase - min_value, max_value - min_value) + min_value;
scale = std::min(std::max(scale, min_phase), max_phase);
break;
case 2:
scale = fmod(phase - min_value, (max_value - min_value) * 2) + min_value;
if (scale > max_value) scale = max_value - (scale - max_value);
scale = std::min(std::max(scale, min_phase), max_phase);
break;
default:
scale = std::min(std::max(phase, min_phase), max_phase);
}
return scale;
return scale;
}
ace::simulation::bone::bone(
const std::string _name,
const std::vector<std::string> &children,
const std::map<std::string, ace::p3d::bone_p> &p3d_bones,
bone *_parent,
const ace::p3d::model_p p3d,
object * sim_object
) : parent(_parent), name(_name), base_object(sim_object)
const std::string _name,
const std::vector<std::string> &children,
const std::map<std::string, ace::p3d::bone_p> &p3d_bones,
bone *_parent,
const ace::p3d::model_p p3d,
object * sim_object
) : parent(_parent), name(_name), base_object(sim_object)
{
for (auto const child_bone : children) {
if (sim_object->all_bones.find(child_bone) == sim_object->all_bones.end()) {
ace::p3d::bone_p p3d_bone = p3d_bones.find(child_bone)->second;
sim_object->all_bones[child_bone] = std::make_shared<bone>(p3d_bone->name, p3d_bone->children, p3d_bones, this, p3d, sim_object);
}
this->children.push_back(sim_object->all_bones[child_bone]);
}
if (parent) {
for (auto p3d_animation : p3d_bones.find(name)->second->animations) {
this->animations.push_back(sim_object->animations[p3d_animation]);
}
}
for (auto const child_bone : children) {
if (sim_object->all_bones.find(child_bone) == sim_object->all_bones.end()) {
ace::p3d::bone_p p3d_bone = p3d_bones.find(child_bone)->second;
sim_object->all_bones[child_bone] = std::make_shared<bone>(p3d_bone->name, p3d_bone->children, p3d_bones, this, p3d, sim_object);
}
this->children.push_back(sim_object->all_bones[child_bone]);
}
if (parent) {
for (auto p3d_animation : p3d_bones.find(name)->second->animations) {
this->animations.push_back(sim_object->animations[p3d_animation]);
}
}
}
void ace::simulation::bone::animate(const std::map<std::string, float> &animation_state, const std::vector<uint32_t> &lods, animation_transform base_transforms)
{
if (animations.size() > 0) {
for (auto bone_animation : animations) {
if(animation_state.find(bone_animation->name) != animation_state.end()) {
base_transforms = bone_animation->animate(animation_state.find(bone_animation->name)->second, lods, base_transforms);
}
}
}
for (auto child_bone : children) {
child_bone->animate(animation_state, lods, base_transforms);
}
if(animations.size() > 0) {
for (auto bone_animation : animations) {
for (auto lod_id : lods) {
auto selection = this->base_object->lods[lod_id]->selections.find(this->name);
if(selection != this->base_object->lods[lod_id]->selections.end()) {
selection->second->animate(base_transforms[lod_id].first, base_transforms[lod_id].second);
}
}
}
}
if (animations.size() > 0) {
for (auto bone_animation : animations) {
if (animation_state.find(bone_animation->name) != animation_state.end()) {
base_transforms = bone_animation->animate(animation_state.find(bone_animation->name)->second, lods, base_transforms);
}
}
}
for (auto child_bone : children) {
child_bone->animate(animation_state, lods, base_transforms);
}
if (animations.size() > 0) {
for (auto bone_animation : animations) {
for (auto lod_id : lods) {
auto selection = this->base_object->lods[lod_id]->selections.find(this->name);
if (selection != this->base_object->lods[lod_id]->selections.end()) {
selection->second->animate(base_transforms[lod_id].first, base_transforms[lod_id].second);
}
}
}
}
}
ace::simulation::object::object()
@ -389,27 +410,27 @@ ace::simulation::object::object()
ace::simulation::object::object(const ace::p3d::model_p model)
{
for (ace::p3d::lod_p p3d_lod : model->lods) {
lod_p new_lod = std::make_shared<lod>(p3d_lod, model);
this->lods.push_back(new_lod);
for (ace::p3d::lod_p p3d_lod : model->lods) {
lod_p new_lod = std::make_shared<lod>(p3d_lod, model);
this->lods.push_back(new_lod);
this->lods[p3d_lod->id]->type = model->info->resolutions[p3d_lod->id];
}
}
for (ace::p3d::animation_p p3d_animation : model->animations) {
this->animations.push_back(std::make_shared<animation>(this, p3d_animation, model));
}
for (ace::p3d::animation_p p3d_animation : model->animations) {
this->animations.push_back(std::make_shared<animation>(this, p3d_animation, model));
}
std::map<std::string, ace::p3d::bone_p> p3d_bones;
for (auto const skeleton_bone : model->skeleton->all_bones) {
p3d_bones[skeleton_bone->name] = skeleton_bone;
}
std::map<std::string, ace::p3d::bone_p> p3d_bones;
for (auto const skeleton_bone : model->skeleton->all_bones) {
p3d_bones[skeleton_bone->name] = skeleton_bone;
}
std::vector<std::string> root_bones;
for (auto const root_bone : model->skeleton->root_bones) {
root_bones.push_back(root_bone.first);
}
std::vector<std::string> root_bones;
for (auto const root_bone : model->skeleton->root_bones) {
root_bones.push_back(root_bone.first);
}
this->root_bone = std::make_shared<bone>("", root_bones, p3d_bones, nullptr, model, this);
this->root_bone = std::make_shared<bone>("", root_bones, p3d_bones, nullptr, model, this);
}
@ -421,12 +442,12 @@ ace::simulation::object::~object()
void ace::simulation::object::animate(const std::map<std::string, float> &animation_state, const std::vector<uint32_t> &selected_lods)
{
animation_transform identity_transform;
for (uint32_t lod_id : selected_lods) {
identity_transform[lod_id].first = glm::mat4();
identity_transform[lod_id].second = ace::vector3<float>(0, 0, 0);
}
this->root_bone->animate(animation_state, selected_lods, identity_transform);
animation_transform identity_transform;
for (uint32_t lod_id : selected_lods) {
identity_transform[lod_id].first = glm::mat4();
identity_transform[lod_id].second = ace::vector3<float>(0, 0, 0);
}
this->root_bone->animate(animation_state, selected_lods, identity_transform);
}

8
extensions/tests/longrod_dxtk_test.cpp
View File

@ -69,5 +69,11 @@ int main(int argc, char **argv) {
}
}
getchar();
while (true) {
scanf_s("%s", buffer, sizeof(buffer) - 1);
memset(output, 0x00, sizeof(output));
LOG(INFO) << "Executing: '" << buffer << "'";
RVExtension(output, sizeof(output), buffer);
LOG(INFO) << "Result: '" << output << "'";
}
}

8
extensions/tests/longrod_dxtk_test.txt
View File

@ -1,9 +1,5 @@
#c:\arma\arma3\addons\armor_f_epb.pbo C:\dev\ace3\extensions\tests\longrod_dxtk_test.txt
init:
debug_render:
register_vehicle:\A3\Armor_F_EPB\MBT_03\MBT_03_cannon_F.p3d, 1, 4046.21;3902.56;5.075
#set_animation_state:damageHide, 0, Wheel_kolL1, 4.45242e-005, Wheel_koloL1, 4.45242e-005, Wheel_podkoloL1, 0.520781, Wheel_kolP1, 4.45066e-005, Wheel_koloP1, 4.45066e-005, Wheel_podkoloP1, 0.521964, Wheel_kolL2, 4.45242e-005, Wheel_kolP2, 4.45066e-005, Wheel_koloL2, 4.45242e-005, Wheel_koloL3, 4.45242e-005, Wheel_koloL4, 4.45242e-005, Wheel_koloL5, 4.45242e-005, Wheel_koloL6, 4.45242e-005, Wheel_koloL7, 4.45242e-005, Wheel_koloP2, 4.45066e-005, Wheel_koloP3, 4.45066e-005, Wheel_koloP4, 4.45066e-005, Wheel_koloP5, 4.45066e-005, Wheel_koloP6, 4.45066e-005, Wheel_koloP7, 4.45066e-005, Wheel_podkoloL2, 0.507025, Wheel_podkoloL3, 0.500526, Wheel_podkoloL4, 0.509195, Wheel_podkoloL5, 0.49289, Wheel_podkoloL6, 0.48161, Wheel_podkoloP2, 0.513542, Wheel_podkoloP3, 0.507042, Wheel_podkoloP4, 0.500768, Wheel_podkoloP5, 0.496353, Wheel_podkoloP6, 0.503705, podkoloL1_hide_damage, 0, podkoloL2_hide_damage, 0, podkoloL3_hide_damage, 0, podkoloL4_hide_damage, 0, podkoloL5_hide_damage, 0, podkoloL6_hide_damage, 0, podkoloL7_hide_damage, 0, podkoloL8_hide_damage, 0, podkoloP1_hide_damage, 0, podkoloP2_hide_damage, 0, podkoloP3_hide_damage, 0, podkoloP4_hide_damage, 0, podkoloP5_hide_damage, 0, podkoloP6_hide_damage, 0, podkoloP7_hide_damage, 0, podkoloP8_hide_damage, 0, damageVez, 0, MainTurret, 2.37036, MainGun, 0.347653, Recoil, 0, ObsTurret, 0, ObsGun, 0, MainGunOptics, 0.347653, Wheel_podkoloP7, 0.493503, Wheel_podkoloL7, 0.479849, HatchDriver, 0, HatchCommander, 0, HatchGunner, 0, damageVezVelitele, 0, poklop_commander_damage, 0, poklop_gunner_damage, 0, poklop_driver_damage, 0, zaslehROT_HMG, 0, zaslehROT_coax, 14.094, cannon_muzzle_flash, 0, zaslehROT_cannon, 18, HideHull, 0.303806, HideTurret, 0.0209581, LockMuzzle, 0,
#hit:1, \A3\Armor_F_EPB\MBT_03\MBT_03_cannon_F.p3d, ["damagehide"], 0.984803;0.173649;-0.00285841, 0.0029445;-0.000238176;0.999996, 2, Sh_120mm_APFSDS_Tracer_Yellow, 65, 27, 0, 0, 0, -108.073;1739.99;-17.7792, -18.9268;0.0336914;-1.73933, -0.0619889;0.998028;-0.00989257, 0.173648;-0.984808;-0.000745866
hit:1, \A3\Armor_F_EPB\MBT_03\MBT_03_cannon_F.p3d, [], 0.984803;0.173649;-0.00285841, 0.0029445;-0.000238176;0.999996, 2, Sh_120mm_APFSDS_Tracer_Yellow, 65, 27, 0, 0, 0, -107.792;1724.28;-18.3618, -18.9268;0.0336914;-1.73933, -0.0619889;0.998028;-0.00989257, 0.173648;-0.984808;-0.000746796
#hit:1, \A3\Armor_F_EPB\MBT_03\MBT_03_cannon_F.p3d, [], 0.984803;0.173649;-0.00285841, 0.0029445;-0.000238176;0.999996, 2, Sh_120mm_APFSDS_Tracer_Yellow, 65, 27, 0, 0, 0, -106.921;1703.28;-19.728, -18.9268;0.0336914;-1.73933, -0.0619889;0.998028;-0.00989257, 0.173648;-0.984808;-0.000745866
#hit:1, \A3\Armor_F_EPB\MBT_03\MBT_03_cannon_F.p3d, [], 0.984803;0.173649;-0.00285841, 0.0029445;-0.000238176;0.999996, 2, Sh_120mm_APFSDS_Tracer_Yellow, 65, 27, 0, 0, 0, -92.8136;1569.56;-19.7856, -18.9268;0.0336914;-1.73933, -0.0619889;0.998028;-0.00989257, 0.173648;-0.984808;-0.000746472
#hit:1, \A3\Armor_F_EPB\MBT_03\MBT_03_cannon_F.p3d, ["damagehide"], 0.984803;0.173649;-0.00285841, 0.0029445;-0.000238176;0.999996, 2, Sh_120mm_APFSDS_Tracer_Yellow, 65, 27, 0, 0, 0, -76.7551;1435.97;-17.8176, -18.9268;0.0336914;-1.73933, -0.0619889;0.998028;-0.00989257, 0.173648;-0.984808;-0.000745866
set_animation_state:1,damageHide, 0, Wheel_kolL1, 0, Wheel_koloL1, 0, Wheel_podkoloL1, 1, Wheel_kolP1, 0, Wheel_koloP1, 0, Wheel_podkoloP1, 1, Wheel_kolL2, 0, Wheel_kolP2, 0, Wheel_koloL2, 0, Wheel_koloL3, 0, Wheel_koloL4, 0, Wheel_koloL5, 0, Wheel_koloL6, 0, Wheel_koloL7, 0, Wheel_koloP2, 0, Wheel_koloP3, 0, Wheel_koloP4, 0, Wheel_koloP5, 0, Wheel_koloP6, 0, Wheel_koloP7, 0, Wheel_podkoloL2, 1, Wheel_podkoloL3, 1, Wheel_podkoloL4, 1, Wheel_podkoloL5, 0, Wheel_podkoloL6, 0, Wheel_podkoloP2, 1, Wheel_podkoloP3, 1, Wheel_podkoloP4, 1, Wheel_podkoloP5, 0, Wheel_podkoloP6, 1, podkoloL1_hide_damage, 0, podkoloL2_hide_damage, 0, podkoloL3_hide_damage, 0, podkoloL4_hide_damage, 0, podkoloL5_hide_damage, 0, podkoloL6_hide_damage, 0, podkoloL7_hide_damage, 0, podkoloL8_hide_damage, 0, podkoloP1_hide_damage, 0, podkoloP2_hide_damage, 0, podkoloP3_hide_damage, 0, podkoloP4_hide_damage, 0, podkoloP5_hide_damage, 0, podkoloP6_hide_damage, 0, podkoloP7_hide_damage, 0, podkoloP8_hide_damage, 0, damageVez, 0, MainTurret, -3, MainGun, 0, Recoil, 0, ObsTurret, -0, ObsGun, 0, MainGunOptics, 0, Wheel_podkoloP7, 0, Wheel_podkoloL7, 0, HatchDriver, 0, HatchCommander, 0, HatchGunner, 0, damageVezVelitele, 0, poklop_commander_damage, 0, poklop_gunner_damage, 0, poklop_driver_damage, 0, zaslehROT_HMG, 101, zaslehROT_coax, 16, cannon_muzzle_flash, 0, zaslehROT_cannon, 956, HideHull, 1, HideTurret, 1, LockMuzzle, 0

3
extensions/tests/longrod_dxtk_test.txt.backup
View File

@ -1,5 +1,6 @@
#c:\arma\arma3\addons\structures_f_ind.pbo C:\dev\ace3\extensions\tests\longrod_dxtk_test.txt.backup
init:
debug_render:
register_vehicle:\A3\Structures_F\Ind\Cargo\Cargo40_blue_F.p3d,0,4050.18;3802.55;5.075
set_animation_state:Door_1_rot,1,Door_Locked_1_rot,0,Door_2_rot,0,Door_Locked_2_rot,0,
set_animation_state:0,Door_1_rot,0,Door_Locked_1_rot,0,Door_2_rot,0,Door_Locked_2_rot,0,
fetch_result:1

BIN
extensions/tests/test.p3d
View File

Binary file not shown.

4
extensions/tests/test.pbo.txt
View File

@ -1,3 +1,5 @@
# C:\dev\ace3\extensions\tests\test.pbo C:\dev\ace3\extensions\tests\test.pbo.txt
init:
debug_render:
register_vehicle:\test\test.p3d,2,4050.18;3802.55;5.075
register_vehicle:\test\test.p3d,0,4050.18;3802.55;5.075
set_animation_state:0,box3_rotate,0.5,box3_translate,0,

2
extensions/tests/test_model/config.cpp
View File

@ -18,7 +18,7 @@ class CfgVehicles {
author = "Nou";
_generalMacro = "nou_snow_2x2";
scope = 2;
model = "\x\nou\addons\test_model\test.p3d";
model = "test_model\test.p3d";
vehicleClass = "Structures";
cost = 50000;
replaceDamagedLimit = 0.99999;

5
extensions/vd/base_vehicle.cpp
View File

@ -20,7 +20,8 @@ namespace ace {
}
}
if (fire_lod == -1) // @TODO: fallback on geo LOD
fire_lod = 11;
fire_lod = 0;
//fire_lod = 0;
assert(fire_lod != -1);
// Build the mesh from object faces
@ -58,7 +59,7 @@ namespace ace {
std::vector<uint32_t> lods;
lods.push_back(fire_lod);
object->animate(animation_state, lods);
object->animate(animation_state, lods);
return true;
}

2
extensions/vd/controller.cpp
View File

@ -153,7 +153,7 @@ namespace ace {
if (vehicles.find(id) == vehicles.end())
return false;
for (int x = 0, y = 0; x < vehicles[id]->animation_state.size() && x < _args.size() / 2; x++, y +=2) {
for (int x = 1, y = 1; x < vehicles[id]->animation_state.size() && x < _args.size() / 2; x++, y +=2) {
std::string animation_name = _args[y];
float state = _args[y + 1];
vehicles[id]->animation_state[animation_name] = state;