void simple_min_sort(int* input, int input_size, int k) {
if(0 == input) return;
for(int i=0; i<input_size; i+=k) {
int min_position = min_pos(input + i, input_size - i, k) + i;
swap(input + i, input + min_position);
}
}
void select_sort(int arr[], size_t len)
{
for (size_t i = 0; i < len - 2; i++)
{
swap(&arr[i], min_pos(arr + i, len - i));
}
}
void select_sort(int arr[], size_t len)
{
for(unsigned long i = 0; i< len; i++)
{
int* min = min_pos(arr + i, len - i);
swap(min, &(arr[i]));
}
}
void CMarchingCubeRenderer::Process()
{
if(m_bInitialized) return;
m_bInitialized = true;
int sizeX = m_displayData->GetSizeX();
int sizeY = m_displayData->GetSizeY();
int sizeZ = m_displayData->GetSizeZ();
//计算三个方向的长度，将它缩放到 1x1x1的范围内
//中心在（0.5,0.5,0.5）
vector3df * _3dPosition = new vector3df[sizeX*sizeY*sizeZ];
int posIndex = 0;
//#define max(a,b) ((a)>(b)?(a):(b))
//float voxelSize = 1.0f/(max(max(sizeX,sizeY),sizeZ));
float voxelSize = 1.0f;
//#undef max
float fscale = 1.0f/(std::max(sizeX*m_displayData->GetScaleX(),std::max(sizeY*m_displayData->GetScaleY(),sizeZ*m_displayData->GetScaleZ())));
kk::core::vector3df min_pos(0,0,0);
kk::core::vector3df max_pos(sizeX*m_displayData->GetScaleX()*fscale,
sizeY*m_displayData->GetScaleY()*fscale,
sizeZ*m_displayData->GetScaleZ()*fscale);
float maxValue = 1.0f/std::max(std::max(max_pos.X,max_pos.Y),max_pos.Z);
max_pos *= maxValue;
//中心为
kk::core::vector3df center = (min_pos + max_pos)*0.5f;
//是要移动到（0.5,0.5,0.5），所以偏移量为：
kk::core::vector3df offset=kk::core::vector3df(0.5,0.5,0.5) - center;
for(int x=0;x<sizeX;x++)
for(int y=0;y<sizeY;y++)
for(int z=0;z<sizeZ;z++)
{
posIndex = x+y*sizeX+z*sizeX*sizeY;
//最大轴变为了1
_3dPosition[posIndex].X = x*m_displayData->GetScaleX()*fscale +offset.X;
_3dPosition[posIndex].Y = y*m_displayData->GetScaleY()*fscale +offset.Y;
_3dPosition[posIndex].Z = z*m_displayData->GetScaleZ()*fscale +offset.Z;
//移动到中心来
//就加上了偏移
//posIndex++;
}
vector3df origin;//(-10,-10,-10);
origin.X=0;
origin.Y=0;
origin.Z=0;
//if(mc)
// delete mc;
mc = new MarchingCube(sizeX, sizeY, sizeZ, (float*)(m_displayData->GetRawData()),
_3dPosition, origin, voxelSize, 0.95f);
//delete[] _3dPosition;
}
double inter_cylindre(t_pos xyz, t_win mw, int i)
{
double var[10];
t_calc disc;
calcul_cylindre(var, &xyz, &mw, i);
inter_disque_cyl(xyz, mw, &disc, i);
if ((disc.x * disc.x) + (disc.y * disc.y) <= (mw.tab_obj[i].rayon *
mw.tab_obj[i].rayon))
return (min_pos(disc.k, var[0]));
if ((disc.x2 * disc.x2) + (disc.y2 * disc.y2) <= (mw.tab_obj[i].rayon *
mw.tab_obj[i].rayon))
return (min_pos(disc.k2, var[0]));
if (var[7] < -mw.tab_obj[i].taille / 2 ||
var[7] > mw.tab_obj[i].taille / 2 &&
(var[8] < -mw.tab_obj[i].taille / 2 ||
var[8] > mw.tab_obj[i].taille / 2))
return (-1);
if (var[1] >= 0)
return (var[0]);
}
INLINE_IF_HEADER_ONLY Annotation const DomainGraph::
annotate ( Component const& vertices ) const {
uint64_t D = data_ ->parameter_ . network() . size ();
std::vector<uint64_t> limits = data_ -> parameter_ . network() . domains ();
std::vector<uint64_t> domain_indices ( vertices.begin(), vertices.end() );
std::vector<uint64_t> min_pos(D);
std::vector<uint64_t> max_pos(D);
for ( int d = 0; d < D; ++ d ) {
min_pos[d] = limits[d];
max_pos[d] = 0;
}
for ( int d = 0; d < D; ++ d ) {
for ( uint64_t & v : domain_indices ) {
uint64_t pos = v % limits[d];
v = v / limits[d];
min_pos[d] = std::min(min_pos[d], pos);
max_pos[d] = std::max(max_pos[d], pos);
}
}
std::vector<uint64_t> signature;
for ( int d = 0; d < D; ++ d ) {
if ( min_pos[d] != max_pos[d] ) {
signature . push_back ( d );
}
}
Annotation a;
std::stringstream ss;
if ( signature . size () == 0 ) {
ss << "FP";
bool all_on = true;
bool all_off = true;
for ( int d = 0; d < D; ++ d ) {
if ( min_pos[d] == 0 ) all_on = false;
else all_off = false;
}
if ( all_on ) ss << " ON";
if ( all_off) ss << " OFF";
} else if ( signature . size () == D ) {
ss << "FC";
} else {
ss << "XC {";
bool first_term = true;
for ( uint64_t d : signature ) {
if ( first_term ) first_term = false; else ss << ", ";
ss << data_ ->parameter_ . network() . name ( d );
}
ss << "}";
}
a . append ( ss . str () );
return a;
}
int Ca_Axis_::update(){
double _k=k_;
double _q=q_;
min_pos_=min_pos();
max_pos_=max_pos();
if (min_==max_)
k_=0;
else
if(scale_ & CA_LOG){
k_=(max_pos_-min_pos_)/(log(max_)-log(min_));
q_=min_pos_-k_*log(min_);
}else{
k_=(max_pos_-min_pos_)/(max_-min_);
q_=min_pos_;
}
if((_k!=k_)||(_q!=q_))
return 1;
else
return 0;
};
void calcul_cylindre(double *var, t_pos *xyz, t_win *mw, int i)
{
rotate_trans(xyz, mw, i);
var[2] = xyz->x * xyz->x + xyz->y * xyz->y;
var[3] = 2.0 * (mw->p_oeil.x * xyz->x + mw->p_oeil.y * xyz->y);
var[4] = mw->p_oeil.x * mw->p_oeil.x + mw->p_oeil.y * mw->p_oeil.y -
mw->tab_obj[i].rayon * mw->tab_obj[i].rayon;
var[1] = var[3] * var[3] - 4.0 * var[2] * var[4];
var[5] = (-var[3] + sqrt(var[1])) / (2 * var[2]);
var[6] = (-var[3] - sqrt(var[1])) / (2 * var[2]);
var[0] = min_pos(var[5], var[6]);
if (var[5] > var[6])
{
var[7] = mw->p_oeil.z + var[6] * xyz->z;
var[8] = mw->p_oeil.z + var[5] * xyz->z;
}
else
{
var[7] = mw->p_oeil.z + var[5] * xyz->z;
var[8] = mw->p_oeil.z + var[6] * xyz->z;
}
}
sf::Vector2i ShipTemplate::interiorSize()
{
sf::Vector2i min_pos(1000, 1000);
sf::Vector2i max_pos(0, 0);
for(unsigned int n=0; n<rooms.size(); n++)
{
min_pos.x = std::min(min_pos.x, rooms[n].position.x);
min_pos.y = std::min(min_pos.y, rooms[n].position.y);
max_pos.x = std::max(max_pos.x, rooms[n].position.x + rooms[n].size.x);
max_pos.y = std::max(max_pos.y, rooms[n].position.y + rooms[n].size.y);
}
if (min_pos != sf::Vector2i(1, 1))
{
sf::Vector2i offset = sf::Vector2i(1, 1) - min_pos;
for(unsigned int n=0; n<rooms.size(); n++)
rooms[n].position += offset;
for(unsigned int n=0; n<doors.size(); n++)
doors[n].position += offset;
max_pos += offset;
}
max_pos += sf::Vector2i(1, 1);
return max_pos;
}
int min_pos(int* input, int input_size) {
min_pos(input, input_size, 1);
}
void SubThreadStage()
{
ResIdentifierPtr psmm_input = ResLoader::Instance().Open(ps_desc_.res_name);
KlayGE::XMLDocument doc;
XMLNodePtr root = doc.Parse(psmm_input);
{
XMLNodePtr particle_node = root->FirstNode("particle");
{
XMLNodePtr alpha_node = particle_node->FirstNode("alpha");
ps_desc_.ps_data->particle_alpha_from_tex = alpha_node->Attrib("from")->ValueString();
ps_desc_.ps_data->particle_alpha_to_tex = alpha_node->Attrib("to")->ValueString();
}
{
XMLNodePtr color_node = particle_node->FirstNode("color");
{
Color from;
XMLAttributePtr attr = color_node->Attrib("from");
if (attr)
{
std::vector<std::string> strs;
boost::algorithm::split(strs, attr->ValueString(), boost::is_any_of(" "));
for (size_t i = 0; i < 3; ++ i)
{
if (i < strs.size())
{
boost::algorithm::trim(strs[i]);
from[i] = static_cast<float>(atof(strs[i].c_str()));
}
else
{
from[i] = 0;
}
}
}
from.a() = 1;
ps_desc_.ps_data->particle_color_from = from;
Color to;
attr = color_node->Attrib("to");
if (attr)
{
std::vector<std::string> strs;
boost::algorithm::split(strs, attr->ValueString(), boost::is_any_of(" "));
for (size_t i = 0; i < 3; ++ i)
{
if (i < strs.size())
{
boost::algorithm::trim(strs[i]);
to[i] = static_cast<float>(atof(strs[i].c_str()));
}
else
{
to[i] = 0;
}
}
}
to.a() = 1;
ps_desc_.ps_data->particle_color_to = to;
}
}
}
{
XMLNodePtr emitter_node = root->FirstNode("emitter");
XMLAttributePtr type_attr = emitter_node->Attrib("type");
if (type_attr)
{
ps_desc_.ps_data->emitter_type = type_attr->ValueString();
}
else
{
ps_desc_.ps_data->emitter_type = "point";
}
XMLNodePtr freq_node = emitter_node->FirstNode("frequency");
if (freq_node)
{
XMLAttributePtr attr = freq_node->Attrib("value");
ps_desc_.ps_data->frequency = attr->ValueFloat();
}
XMLNodePtr angle_node = emitter_node->FirstNode("angle");
if (angle_node)
{
XMLAttributePtr attr = angle_node->Attrib("value");
ps_desc_.ps_data->angle = attr->ValueInt() * DEG2RAD;
}
XMLNodePtr pos_node = emitter_node->FirstNode("pos");
if (pos_node)
{
float3 min_pos(0, 0, 0);
XMLAttributePtr attr = pos_node->Attrib("min");
if (attr)
{
std::vector<std::string> strs;
boost::algorithm::split(strs, attr->ValueString(), boost::is_any_of(" "));
for (size_t i = 0; i < 3; ++ i)
{
if (i < strs.size())
{
boost::algorithm::trim(strs[i]);
min_pos[i] = static_cast<float>(atof(strs[i].c_str()));
}
else
{
min_pos[i] = 0;
}
}
}
ps_desc_.ps_data->min_pos = min_pos;
float3 max_pos(0, 0, 0);
attr = pos_node->Attrib("max");
if (attr)
{
std::vector<std::string> strs;
boost::algorithm::split(strs, attr->ValueString(), boost::is_any_of(" "));
for (size_t i = 0; i < 3; ++ i)
{
if (i < strs.size())
{
boost::algorithm::trim(strs[i]);
max_pos[i] = static_cast<float>(atof(strs[i].c_str()));
}
else
{
max_pos[i] = 0;
}
}
}
ps_desc_.ps_data->max_pos = max_pos;
}
XMLNodePtr vel_node = emitter_node->FirstNode("vel");
if (vel_node)
{
XMLAttributePtr attr = vel_node->Attrib("min");
ps_desc_.ps_data->min_vel = attr->ValueFloat();
attr = vel_node->Attrib("max");
ps_desc_.ps_data->max_vel = attr->ValueFloat();
}
XMLNodePtr life_node = emitter_node->FirstNode("life");
if (life_node)
{
XMLAttributePtr attr = life_node->Attrib("min");
ps_desc_.ps_data->min_life = attr->ValueFloat();
attr = life_node->Attrib("max");
ps_desc_.ps_data->max_life = attr->ValueFloat();
}
}
{
XMLNodePtr updater_node = root->FirstNode("updater");
XMLAttributePtr type_attr = updater_node->Attrib("type");
if (type_attr)
{
ps_desc_.ps_data->updater_type = type_attr->ValueString();
}
else
{
ps_desc_.ps_data->updater_type = "polyline";
}
if ("polyline" == ps_desc_.ps_data->updater_type)
{
for (XMLNodePtr node = updater_node->FirstNode("curve"); node; node = node->NextSibling("curve"))
{
std::vector<float2> xys;
for (XMLNodePtr ctrl_point_node = node->FirstNode("ctrl_point"); ctrl_point_node; ctrl_point_node = ctrl_point_node->NextSibling("ctrl_point"))
{
XMLAttributePtr attr_x = ctrl_point_node->Attrib("x");
XMLAttributePtr attr_y = ctrl_point_node->Attrib("y");
xys.push_back(float2(attr_x->ValueFloat(), attr_y->ValueFloat()));
}
XMLAttributePtr attr = node->Attrib("name");
size_t const name_hash = RT_HASH(attr->ValueString().c_str());
if (CT_HASH("size_over_life") == name_hash)
{
ps_desc_.ps_data->size_over_life_ctrl_pts = xys;
}
else if (CT_HASH("mass_over_life") == name_hash)
{
ps_desc_.ps_data->mass_over_life_ctrl_pts = xys;
}
else if (CT_HASH("opacity_over_life") == name_hash)
{
ps_desc_.ps_data->opacity_over_life_ctrl_pts = xys;
}
}
}
}
RenderFactory& rf = Context::Instance().RenderFactoryInstance();
RenderDeviceCaps const & caps = rf.RenderEngineInstance().DeviceCaps();
if (caps.multithread_res_creating_support)
{
this->MainThreadStage();
}
}
