/// Computes lighting for the entire scene
void computeLighting()
{
for (auto &ridge : mountains)
{
for (int i=0; i < ridge.meshVertices.size(); i = i+3)
{
// Compute for our (single) light
Vec3Df vertexpos = Vec3Df(ridge.meshVertices[i],
ridge.meshVertices[i+1],
ridge.meshVertices[i+2]);
Vec3Df normal = Vec3Df(ridge.meshNormals[i],
ridge.meshNormals[i+1],
ridge.meshNormals[i+2]);
Vec3Df lighting = computeLighting(vertexpos, normal, DIFFUSE_LIGHTING);
// Pass computed values to Ridge
ridge.meshColors[i] = lighting[0];
ridge.meshColors[i+1] = lighting[1];
ridge.meshColors[i+2] = lighting[2];
}
}
if (toggleBoss) {
std::vector<Vertex> vertices = boss.getMesh().vertices;
std::vector<Vec3Df> meshColors = std::vector<Vec3Df>(vertices.size());
auto rotMat = matrixMultiplication(
rotateMatrixY(boss.angleHeadY*M_PI / 180),
rotateMatrixX(boss.angleHeadZ*M_PI / 180)
);
for (int i = 0; i < vertices.size(); i++)
{
// Compute for our (single) light
Vertex vertex = vertices[i];
Vec3Df vec = vertex.p;
vec = calculateMatrix(rotMat, vec);
vec = vec + boss.translation;
vec = vec * boss.scale;
vec = vec + boss.position;
Vec3Df nor = vertex.n;
nor = calculateMatrix(rotMat, nor);
nor = nor + boss.translation;
nor = nor * boss.scale;
nor = nor + boss.position;
Vec3Df lighting = computeLighting(vec, nor, PHONG_LIGHTNING);
meshColors[i] = lighting;
}
boss.getMesh().meshColor = meshColors;
}
}
//take input file from fortran code and convert into format which can be processed by this code, so we can check if equivalent
int convert(int mat[SIZE1][SIZE2],char *infile,char *outfile,int * numbers)
{
printf("reading in data file \n");
int swit2,count,n,val;
struct entry bob;
FILE * fpin;
FILE * fpout;
char text [1000];
fpin=fopen(infile,"r");
fpout=fopen(outfile,"w");
(*numbers)=0; //we don't know how many results we are reading in
fgets(&text[0],1000,fpin); //get first two lines
fgets(&text[0],1000,fpin);
swit2=0;
while(1)
{
//code for locating set of values from line and extracting
count=0;
while(count<SIZE1)
{
//second method for simpler output format
fscanf(fpin,"%d",&val);
if(feof(fpin)) //end of file indicator, read in all words which are part of matrices
{
swit2=1;
break;
}
//printf("%d \n",val);
bob.rows[count]=val;
//printf("%d \n",bob.rows[count]);
count++;
}
if(swit2==1)
{
break;
}
if(count==SIZE1) //if there are SIZE1 components read in, print out matrix to outfile
{
calculateMatrix(bob,mat);
//displayentry(bob,NULL);
displaymatrix(mat,fpout);
(*numbers)++;
fgets(&text[0],1000,fpin); //go to next line
}
}
//printdata(data,size1,(*numbers));
printf("read data in \n");
printf("numbers %d \n",(*numbers));
fclose(fpin);
fclose(fpout);
return 0;
}
void ModifiedPatankarRK(int dim_matrix, double oldvalue[], double dt, double newvalue[], recomb_t *thisRecombRates, cell_t *thisCell){
double intervalue[dim_matrix];
double oldvalue_local[dim_matrix];
double newvalue_local[dim_matrix];
double destr_rate[dim_matrix][dim_matrix];
double inter_destr_rate[dim_matrix][dim_matrix];
double matrix[dim_matrix][dim_matrix];
initializeVector(dim_matrix, oldvalue_local, oldvalue);
initializeVector(dim_matrix, newvalue_local, oldvalue);
// printf("oldvalue_local[0] = %e\toldvalue_local[1] = %e\n", oldvalue_local[0], oldvalue_local[1]);
// First Runge Kutta step
initializeVector(dim_matrix, oldvalue_local, newvalue_local); //oldvalue = x
create_rate_functions(dim_matrix, destr_rate, oldvalue_local, thisRecombRates, thisCell); //calculate destruction rates
calculateMatrix(dim_matrix, dt, matrix, destr_rate, oldvalue_local); //calculate matrix for destr_rate and oldvalue
solveSetOfEquations(dim_matrix, matrix, oldvalue_local, intervalue); //Solve set of equations for intervalue
checkVector(dim_matrix,intervalue);
// Second Runge Kutta step
initializeVector(dim_matrix, oldvalue_local, oldvalue); //oldvalue = newvalue
create_rate_functions(dim_matrix, inter_destr_rate, intervalue, thisRecombRates, thisCell); //calculate new destruction rates from intervalue
add_rate_functions(dim_matrix, inter_destr_rate, destr_rate); //add rate functions destr_rate and interdestr_rate, output on interdestr_rate
calculateMatrix(dim_matrix, dt*0.5, matrix, inter_destr_rate, intervalue); //calculate matrix for interdestr_rate and intervalue
solveSetOfEquations(dim_matrix, matrix, oldvalue_local, newvalue_local); //solve set of equations for newvalue
checkVector(dim_matrix, newvalue_local);
initializeVector(dim_matrix, newvalue, newvalue_local);
}
//Генерация узлов
bool Environment::generateNodes(int nodeCount)
{
const int maxAttemps = 9999;
int attemps = 0;
this->nodeCount = nodeCount;
cout << "Инициализация узлов\n\n";
cout << "Размер области: " << xSize << " x "<< ySize << "\n\n";
cout << "Запрет на передачу при приеме ";
if (Simulator::getInstance().mode == DisableTransmittingMode_RTS) cout <<"RTS\n\n";
else cout << "CTS\n\n";
generateNodesAttempt();
//проверяем связность сети
while ((!(isNetworkConnected()))&&(attemps < maxAttemps))
{
attemps++;
this->clear();
Simulator::getInstance().getEventQueue()->clear();
// cout << "Сеть несвязна, перегенерируем координаты узлов "<<1+attemps<<" раз\n";
generateNodesAttempt();
}
calculateMatrix();
if (isNetworkConnected())
{
for (int nodeMac = 0; nodeMac < nodeCount; nodeMac++)
{
BSSNode* node = nodes[nodeMac];
cout<<"Узел P"<<nodeMac<<" добавлен: X="<<node->getX()<<" Y="<<node->getY()<<", момент включения = "<<node->getTimeOn()<<"\n";
}
// printMatrix();
return true;
}
else
return false;
}
int sort(char * fname, int counts, int mat[SIZE1][SIZE2])
{
FILE * fp;
int n,n1,n2, inti,max,start,maxdiff;
struct fullentry * matrices;
int minsidelobes [MAXONES];
fp=fopen(fname,"r");
matrices=(struct fullentry *)calloc(counts,sizeof(struct fullentry));
printf("Beginning to sort results \n");
max=0;
for(n=0; n<MAXONES; n++)
{
minsidelobes[n]=100;
}
for(n=0; n<counts; n++)
{
for(n2=0; n2<SIZE2; n2++)
{
for(n1=0; n1<SIZE1; n1++)
{
fscanf(fp,"%d ",&inti);
mat[n1][n2]=inti;
}
fscanf(fp,"\n ",&inti);
}
lexleast(mat,1);
calculateFullEntry(mat,&matrices[n]);
//displayentry(matrices[n].intrep,NULL);
if(matrices[n].ones>max)
max=matrices[n].ones;
if(minsidelobes[matrices[n].ones]>matrices[n].peaksidelobe)
minsidelobes[matrices[n].ones]=matrices[n].peaksidelobe;
}
fclose(fp);
printf("Maximum ones reached in search is %d \n",max);
printf("optimal sidelobe for each level \n");
start=-1;
//
//printf("minones %d max %d \n",MINONES,max);
int min=100;
//need to be careful here, get start of range and minimum sidelobe independently
for(n=MINONES; n<=max; n++)
{
//printf("%d \n",minsidelobes[n]);
if(minsidelobes[n]<min)
{
min=minsidelobes[n];
}
if(start==-1 && minsidelobes[n]!=100)
start=n;
if(start!=-1)
printf("%d ",minsidelobes[n]);
}
printf(" \n");
//create matrix for storing sidelobe and length statistics, if find lower sidelobe, need to also break down by sidelobe
int * counttype=(int *)calloc((max-start+1)*(MAXSIDELOBE-min+1),sizeof(int));
qsort((void *)matrices,counts,sizeof(struct fullentry),comparefullentry);
n2=0;
//now print out only the unique entries
fp=fopen(fname,"w");
fprintf(fp,"Matrices for maximum sidelobe %d with dimensions %d by %d \n",MAXSIDELOBE,SIZE1,SIZE2);
//need to print out 1st matrix in list first, code works by printing out 1st unique matrix of sorted group and ignoring the rest
calculateMatrix(matrices[0].intrep,mat);
displaymatrix(mat,fp);
displayentry(matrices[0].intrep,fp);
fprintf(fp,"\n");
//printf("start %d \n",start);
counttype[(max-start+1)*(matrices[0].peaksidelobe-min)+matrices[0].ones-start]++;
for(n1=0; n1<=MAXSIDELOBE; n1++)
{
fprintf(fp,"%d ",matrices[0].spectrum[n1]);
}
fprintf(fp," \n");
fprintf(fp, "ones %d, peak sidelobe %d \n \n",matrices[0].ones,matrices[0].peaksidelobe);
n2++;
maxdiff=matrices[0].ones-matrices[0].peaksidelobe;
printf("range for table is %d ones to %d, and sidelobe %d to %d \n",max,start,MAXSIDELOBE,min);
printf("entering loop %d counts \n",counts);
for(n=1; n<counts; n++)
{
if(compareentry(&matrices[n],&matrices[n-1])!=0) //do not print out as long as previous entry same as current entry
{
calculateMatrix(matrices[n].intrep,mat);
if(matrices[n].peaksidelobe>MAXSIDELOBE)
continue;
displaymatrix(mat,fp);
displayentry(matrices[n].intrep,fp);
fprintf(fp,"\n");
for(n1=0; n1<=MAXSIDELOBE; n1++)
{
fprintf(fp,"%d ",matrices[n].spectrum[n1]);
}
fprintf(fp," \n");
fprintf(fp, "ones %d, peak sidelobe %d \n \n",matrices[n].ones,matrices[n].peaksidelobe);
//printf("%d %d \n",(max-start+1)*(matrices[n].peaksidelobe-min)+matrices[n].ones-start,(max-start+1)*(MAXSIDELOBE-min+1));
//printf("%d peaksidelobe, %d ones \n",matrices[n].peaksidelobe,matrices[n].ones);
counttype[(max-start+1)*(matrices[n].peaksidelobe-min)+matrices[n].ones-start]++;
n2++;
if((matrices[0].ones-matrices[0].peaksidelobe)>maxdiff)
maxdiff=(matrices[0].ones-matrices[0].peaksidelobe);
}
}
fprintf(fp,"Total Unique matrices are %d \n",n2);
printf("sorted through matrices and eliminated redundant elements, have %d unique matrices out of %d \n",n2,counts);
fprintf(fp,"Maximum ones reached in search is %d \n",max);
fprintf(fp,"optimal sidelobe for each level \n");
for(n=start; n<=max; n++)
fprintf(fp,"%d : %d ",n,minsidelobes[n]);
fprintf(fp," \n");
printf("maxdiff is %d, start is %d, max is %d \n",maxdiff,start,max);
printf("printing out table \n");
//print out table of counts to give breakdown and sidelobe and int counts for given max
for(n1=0; n1<=(max-start); n1++)
{
fprintf(fp," \n");
if(n1==0)
fprintf(fp," ");
else
fprintf(fp,"%d ",n1+start);
for(n2=0; n2<=(MAXSIDELOBE-min); n2++)
{
if(n1==0)
fprintf(fp,"%d ",n2+min);
else
fprintf(fp,"%d ",counttype[(max-start+1)*n2+(n1)]);
}
}
printf("finished loop \n");
//needs to also give sum of lowest diagonal corresponding to highest max
int sum=0;
for(n1=0; n1<=(max-start); n1++)
{
//printf("%d \n",start+n1-maxdiff-minsidelobes[start]);
if((start+n1-maxdiff-min)>=0) //if not lined up properly can give sidelobe we did not include before
sum=sum+counttype[(max-start+1)*(start+n1-maxdiff-min)+n1]; //need to sweep constant diffmax contour
}
printf("\n \n There are %d results with optimal difference of %d \n",sum,maxdiff);
fprintf(fp,"\n \n There are %d results with optimal difference of %d \n",sum,maxdiff);
fclose(fp);
printf("reached end \n");
return 0;
}
void SceneObject::setOrientation(glm::quat tquat)
{
m_Orientation = tquat;
calculateMatrix();
}
void SceneObject::setPosition(glm::vec4 tvec4)
{
m_Position = tvec4;
calculateMatrix();
}
void SceneObject::setPosition(glm::vec3 tvec3)
{
m_Position = glm::vec4(tvec3,1.0f);
calculateMatrix();
}
void CD3DCG::Render(LPDIRECT3DTEXTURE9 &origTex, D3DXVECTOR2 textureSize,
D3DXVECTOR2 inputSize, D3DXVECTOR2 viewportSize, D3DXVECTOR2 windowSize)
{
LPDIRECT3DSURFACE9 pRenderSurface = NULL,pBackBuffer = NULL;
frameCnt++;
if(!shaderLoaded)
return;
/* save back buffer render target
*/
pDevice->GetRenderTarget(0,&pBackBuffer);
/* pass 0 represents the original texture
*/
shaderPasses[0].tex = origTex;
shaderPasses[0].outputSize = inputSize;
shaderPasses[0].textureSize = textureSize;
calculateMatrix();
for(int i=1;i<shaderPasses.size();i++) {
switch(shaderPasses[i].scaleParams.scaleTypeX) {
case CG_SCALE_ABSOLUTE:
shaderPasses[i].outputSize.x = (double)shaderPasses[i].scaleParams.absX;
break;
case CG_SCALE_SOURCE:
shaderPasses[i].outputSize.x = shaderPasses[i-1].outputSize.x * shaderPasses[i].scaleParams.scaleX;
break;
case CG_SCALE_VIEWPORT:
shaderPasses[i].outputSize.x = viewportSize.x * shaderPasses[i].scaleParams.scaleX;
break;
default:
shaderPasses[i].outputSize.x = viewportSize.x;
}
switch(shaderPasses[i].scaleParams.scaleTypeY) {
case CG_SCALE_ABSOLUTE:
shaderPasses[i].outputSize.y = (double)shaderPasses[i].scaleParams.absY;
break;
case CG_SCALE_SOURCE:
shaderPasses[i].outputSize.y = shaderPasses[i-1].outputSize.y * shaderPasses[i].scaleParams.scaleY;
break;
case CG_SCALE_VIEWPORT:
shaderPasses[i].outputSize.y = viewportSize.y * shaderPasses[i].scaleParams.scaleY;
break;
default:
shaderPasses[i].outputSize.y = viewportSize.y;
}
float texSize = npot(max(shaderPasses[i].outputSize.x,shaderPasses[i].outputSize.y));
/* make sure the render target exists and has an appropriate size,
then set as current render target with last pass as source
*/
ensureTextureSize(shaderPasses[i].tex,shaderPasses[i].textureSize,D3DXVECTOR2(texSize,texSize),true);
shaderPasses[i].tex->GetSurfaceLevel(0,&pRenderSurface);
pDevice->SetTexture(0, shaderPasses[i-1].tex);
pDevice->SetRenderTarget(0,pRenderSurface);
pRenderSurface->Release();
/* set vertex declaration of current pass, update vertex
buffer and set base streams
*/
pDevice->SetVertexDeclaration(shaderPasses[i].vertexDeclaration);
setVertexStream(shaderPasses[i].vertexBuffer,
shaderPasses[i-1].outputSize,shaderPasses[i-1].textureSize,shaderPasses[i].outputSize);
pDevice->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_BORDER);
pDevice->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_BORDER);
pDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, shaderPasses[i].linearFilter?D3DTEXF_LINEAR:D3DTEXF_POINT);
pDevice->SetSamplerState(0, D3DSAMP_MINFILTER, shaderPasses[i].linearFilter?D3DTEXF_LINEAR:D3DTEXF_POINT);
/* shader vars need to be set after the base vertex streams
have been set so they can override them
*/
setShaderVars(i);
cgD3D9BindProgram(shaderPasses[i].cgVertexProgram);
checkForCgError("Binding vertex program");
cgD3D9BindProgram(shaderPasses[i].cgFragmentProgram);
checkForCgError("Binding fragment program");
/* viewport defines output size
*/
setViewport(0,0,shaderPasses[i].outputSize.x,shaderPasses[i].outputSize.y);
pDevice->BeginScene();
pDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2);
pDevice->EndScene();
}
/* take oldes PREV out of deque, make sure it has
the same size as the current texture and
then set it up as new original texture
*/
prevPass &oldestPrev = prevPasses.back();
ensureTextureSize(oldestPrev.tex,oldestPrev.textureSize,textureSize,false);
if(oldestPrev.vertexBuffer)
oldestPrev.vertexBuffer->Release();
origTex = oldestPrev.tex;
prevPasses.pop_back();
/* push current original with corresponding vertex
buffer to front of PREV deque
*/
shaderPasses[0].vertexBuffer = shaderPasses[1].vertexBuffer;
prevPasses.push_front(prevPass(shaderPasses[0]));
/* create new vertex buffer so that next render call
will not overwrite the PREV
*/
pDevice->CreateVertexBuffer(sizeof(VERTEX)*4,D3DUSAGE_WRITEONLY,0,D3DPOOL_MANAGED,&shaderPasses[1].vertexBuffer,NULL);
/* set up last pass texture, backbuffer and viewport
for final display pass without shaders
*/
pDevice->SetTexture(0, shaderPasses.back().tex);
pDevice->SetRenderTarget(0,pBackBuffer);
pBackBuffer->Release();
RECT displayRect=CalculateDisplayRect(shaderPasses.back().outputSize.x,shaderPasses.back().outputSize.y,windowSize.x,windowSize.y);
setViewport(displayRect.left,displayRect.top,displayRect.right - displayRect.left,displayRect.bottom - displayRect.top);
setVertexStream(shaderPasses.back().vertexBuffer,
shaderPasses.back().outputSize,shaderPasses.back().textureSize,
D3DXVECTOR2(displayRect.right - displayRect.left,displayRect.bottom - displayRect.top));
pDevice->SetVertexShader(NULL);
pDevice->SetPixelShader(NULL);
}
/// Moves the selected vertex by the argument vector.
void moveLastVertex(const Nimble::Vector2 & move)
{ m_vertices[m_selected] += move; calculateMatrix(); }
