bool Dlite::ComputeShortestPath(LocalMap &map)
{
while (OPEN.top_key_less_than(CalculateKey(*start)) || start->rhs != start->g) {
++number_of_steps;
Node* current = OPEN.get();\
Key old_key = current->key;
Key new_key = CalculateKey(*current);
if (old_key < new_key) {
current->key = new_key;
OPEN.put(current);
} else if (current->g > current->rhs) {
current->g = current->rhs;
OPEN.pop();
for (auto elem : GetSuccessors(current, map)) {
if (elem->point != map.goal && elem->rhs > current->g + GetCost(elem->point, current->point, map)) {
elem->parent = current;
elem->rhs = current->g + GetCost(elem->point, current->point, map);
}
UpdateVertex(elem); // !!!<-apparently OK
}
} else {
//double old_g = current->g;
current->g = std::numeric_limits<double>::infinity();
std::vector<Node* > succ = GetSuccessors(current, map);
succ.push_back(current);
for (auto elem : succ) {
if (elem->point != map.goal && elem->parent->point == current->point) {
Node min_val = GetMinPredecessor(elem, map);
elem->rhs = min_val.rhs;
if(min_val.parent)
elem->parent = min_val.parent;
}
UpdateVertex(elem);
}
}
/*if(current->parent) {
std::cout << current->point << "g " << current->g << " rhs" << current->rhs <<
current->parent->point << std::endl;
} */ //std::cout << OPEN.top_key().k1 << std::endl;
//OPEN.print_elements();
}
if (start->rhs != std::numeric_limits<double>::infinity()) {
current_result.pathfound = true;
current_result.numberofsteps = number_of_steps;
current_result.nodescreated = NODES.size();
//std::cout << start->rhs << std::endl;
//MakePrimaryPath(start);
//current_result.lppath = &path;
//map.PrintPath(curpath);
//for (auto elem : curpath) path.push_back(elem);
return true;
} else {
current_result.pathfound = false;
current_result.pathlength = 0;
return false;
}
return false;
}
/// <summary>Encodes a byte array</summary>
/// <param name="buffer">Buffer to encode</param>
/// <param name="length">Length of buffer</param>
/// <param name="streamPos">Stream position matching the first buffer element to be encoded</param>
void CatalogStream::Encode(byte* buffer, DWORD length, DWORD streamPos)
{
byte key = CalculateKey(streamPos);
// Encode buffer
for (DWORD i = 0; i < length; i++)
buffer[i] ^= key++;
}
void Dlite::UpdateVertex(Node* u)
{
if (!(u->IsConsistent())) {
u->key = CalculateKey(*u);
//std::cout << "key: "<< u->key.k1 << " " << u->key.k2 << " " << u->point << std::endl;
OPEN.put(u); //check if it is already there
} else {
OPEN.remove_if(u);
}
}
DWORD CalculateDemoKey::DoCalculateDemoKey(char* folder)
{
DWORD dwCrc32_dxf = 0xD5452A29;
DWORD dwCrc32_rct = 0x33CAEEBF;
DWORD dwCrc32_pgm = 0x6E5415D4;
DWORD dwCrc32_mdb = 0x6A0696B1;
DWORD dwCrc32_trn = 0x4F4AEE74;
DWORD dwCrc32_dat = 0xDF3297AC;
DWORD multiplier_dxf = 0x2BAE3564;
DWORD multiplier_rct = 0x76777938;
DWORD multiplier_pgm = 0x2DCD0605;
DWORD multiplier_mdb = 0xEFA6BF10;
DWORD multiplier_trn = 0xBD367A8F;
DWORD multiplier_dat = 0xD4F8A26A;
CalculateKey(folder, ".dxf", multiplier_dxf, dwCrc32_dxf);
CalculateKey(folder, ".rct", multiplier_rct, dwCrc32_rct);
CalculateKey(folder, ".pgm", multiplier_pgm, dwCrc32_pgm);
CalculateKey(folder, ".mdb", multiplier_mdb, dwCrc32_mdb);
CalculateKey(folder, ".trn", multiplier_trn, dwCrc32_trn);
CalculateKey(folder, ".dat", multiplier_dat, dwCrc32_dat);
return dwCrc32_dxf * multiplier_dxf
^ dwCrc32_rct * multiplier_rct
^ dwCrc32_pgm * multiplier_pgm
^ dwCrc32_mdb * multiplier_mdb
^ dwCrc32_trn * multiplier_trn
^ dwCrc32_dat * multiplier_dat;
}
CompositorPtr HDRCompositor::Create(void)
{
m_Compositor = CompositorManager::getSingleton().create("HDR", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
m_HDRTechnique = m_Compositor->createTechnique();
m_HDRTechnique->setCompositorLogicName("HDR");
CompositionTechnique::TextureDefinition *texdef = m_HDRTechnique->createTextureDefinition("Scene");
texdef->refTexName = "mrt_output";
texdef->refCompName="gbuffer";
// texdef->scope=Ogre::CompositionTechnique::TextureScope::TS_GLOBAL;
//render scene
// CreateTextureDef("Scene",0,0,PF_FLOAT16_RGB);
// CompositionTargetPass *tp = m_HDRTechnique->createTargetPass();
// tp->setInputMode(CompositionTargetPass::IM_PREVIOUS);
// tp->setOutputName("Scene");
RenderDownSample();
CalculateLuminance();
CalculateKey();
if(m_GlareType || m_StarType)
{
BrightPass();
if(m_GlareType)
BuildGlare();
if(m_StarType)
BuildStar();
}
if(m_ToneMapper == TM_REINHARDLOCAL)
BuildScales();
FinalRendering();
return m_Compositor;
}
void lcLight::UpdatePosition(lcStep Step)
{
mPosition = CalculateKey(mPositionKeys, Step);
mTargetPosition = CalculateKey(mTargetPositionKeys, Step);
mAmbientColor = CalculateKey(mAmbientColorKeys, Step);
mDiffuseColor = CalculateKey(mDiffuseColorKeys, Step);
mSpecularColor = CalculateKey(mSpecularColorKeys, Step);
mAttenuation = CalculateKey(mAttenuationKeys, Step);
mSpotCutoff = CalculateKey(mSpotCutoffKeys, Step);
mSpotExponent = CalculateKey(mSpotExponentKeys, Step);
if (IsPointLight())
{
mWorldLight = lcMatrix44Identity();
mWorldLight.SetTranslation(-mPosition);
}
else
{
lcVector3 FrontVector(mTargetPosition - mPosition);
lcVector3 UpVector(1, 1, 1);
if (fabs(FrontVector[0]) < fabs(FrontVector[1]))
{
if (fabs(FrontVector[0]) < fabs(FrontVector[2]))
UpVector[0] = -(UpVector[1] * FrontVector[1] + UpVector[2] * FrontVector[2]);
else
UpVector[2] = -(UpVector[0] * FrontVector[0] + UpVector[1] * FrontVector[1]);
}
else
{
if (fabs(FrontVector[1]) < fabs(FrontVector[2]))
UpVector[1] = -(UpVector[0] * FrontVector[0] + UpVector[2] * FrontVector[2]);
else
UpVector[2] = -(UpVector[0] * FrontVector[0] + UpVector[1] * FrontVector[1]);
}
mWorldLight = lcMatrix44LookAt(mPosition, mTargetPosition, UpVector);
}
}
void Dlite::Initialize(LocalMap &map)
{
Km = 0;
Node start_node = Node(map.start);
start_point = map.start;
Node goal_node = Node(map.goal);
goal_node.rhs = 0;
goal_node.g = std::numeric_limits<double>::infinity();
goal_node.key = CalculateKey(goal_node);
NODES[vertex(map.goal, map.height)] = goal_node;
goal = &(NODES.find(vertex(map.goal, map.height))->second);
start_node.g = std::numeric_limits<double>::infinity();
start_node.rhs = std::numeric_limits<double>::infinity();
NODES[vertex(map.start, map.height)] = start_node;
start = &(NODES.find(vertex(map.start, map.height))->second);
OPEN.resize(map.height);
OPEN.put(goal);
}
