void rayAlhorythm(ElementContainer objects, int width, int height, EdgeInfo** validateEdges, int& count, int dWidth, int dHeight){
ElementContainer::iterator it;
EdgeInfo** edges = new EdgeInfo*[height];
for(int i=0; i<height; ++i){
edges[i] = new EdgeInfo[width];
}
int elemsAmount = objects.size();
point* centers = new point[elemsAmount];
int* radiuses = new int[elemsAmount];
CordContainer* cords;
it = objects.begin();
for(int i=0; i<elemsAmount; ++i){
cords = (*it)->convertedPos;
getContainedCircle(cords->Cords, cords->rows, cords->cols, centers[i], radiuses[i]);
defineVisibleEdges(edges, width, height, *cords, centers[i], radiuses[i], dWidth, dHeight);
it++;
}
getEdges(edges, width, height, validateEdges, count, dWidth, dHeight);
delete[] centers;
delete[] radiuses;
for(int i=0; i<height; ++i){
delete [] edges[i];
}
delete [] edges;
}
void ShadowMap::unloadScene(Scene* scene, uint index_vao)
{
ElementContainer* elements = scene->getElements();
if(elements->getType() == ElementContainer::ARRAY)
unloadSceneArray((ArrayElementContainer*)elements, index_vao);
else
logWarn("container type \"", elements->getTypeStr(), "\" not supported for shadow mapping");
}
// ---------------------------------------------------------------------
// Render a scene from the point of view of a light
void ShadowMap::renderFromLight(const Light* light, Scene* scene, uint index_vao)
{
ElementContainer* elements = scene->getElements();
if(elements->getType() == ElementContainer::ARRAY)
renderFromLightArray(light, (ArrayElementContainer*)elements, index_vao);
else
logWarn("shadow map rendering for non-array element containers not implemented");
}
// ---------------------------------------------------------------------
// Rendering of all shadow maps:
void ShadowMap::renderShadowMaps(Scene* scene, uint vao_index)
{
ElementContainer* elements = scene->getElements();
if(elements->getType() == ElementContainer::ARRAY)
renderShadowMapsArray((ArrayElementContainer*)elements, vao_index);
else
logWarn("container type \"", elements->getTypeStr(), "\" not supported for shadow mapping");
}
void QGraphContainer::drawPrepare(){
for(int i=0; i<1000; ++i){
for(int j=0; j<700; ++j){
this->colorField[j][i].intensity=0;
}
}
DWORD startTime, outerStartTime = GetTickCount();
char str[40];
ElementContainer::iterator it;
ElementContainer::iterator it1;
float progress = ((float)++currentTick + 0.01)/(float)maxTick;
if(currentTick==maxTick){
for(int i=0; i<3; i++){
delete this->selectedEdgeDescriptor[i];
selectedEdgeDescriptor[i]=NULL;
}
for(it=collection.begin(); it!=collection.end(); ++it){
(*it)->clearDescriptionElements();
}
currentTick = 0;
timer.stop();
}
CordContainer* cords;
if(selectedEdgeDescriptor[0]!=NULL){
this->edgeInfoOut(*selectedEdgeDescriptor[0],
*selectedEdgeDescriptor[1],
*selectedEdgeDescriptor[2]);
}
ElementContainer graphDescriptions;
for(it=collection.begin(); it!=collection.end(); ++it){
(*it)->processUpdate(progress);
(*it)->process();
graphDescriptions = (*it)->getDescriptionElements();
for(it1 = graphDescriptions.begin(); it1!=graphDescriptions.end(); it1++){
(*it1)->processUpdate(progress);
(*it1)->process();
}
}
delete [] edgesToDraw;
//rayAlhorythm(collection, 700, 1000, &edgesToDraw, edgesCount, dWidth, dHeight);
edgeNormalCreate((*collection.begin())->convertedPos, edgesToDraw, edgesCount, this->colorField, 700, 1000, point(0, 0, 1), 70);
}
void SymmetryGroup::computeClosure(Permutation const &v) //does this work??
{
ElementContainer newOnes;
newOnes.insert(v);
while(!newOnes.empty())
{
Permutation v=*newOnes.begin();
for(ElementContainer::const_iterator i=elements.begin();i!=elements.end();i++)
{
{
Permutation n=i->apply(v);
if(0==elements.count(n))
newOnes.insert(n);
}
{
Permutation n=v.apply(v);
if(0==elements.count(n))
newOnes.insert(n);
}
}
newOnes.erase(v);
elements.insert(v);
}
}
