forum.boolean.name

forum.boolean.name (http://forum.boolean.name/index.php)
-   Xors3D (http://forum.boolean.name/forumdisplay.php?f=126)
-   -   Странное. (http://forum.boolean.name/showthread.php?t=15405)

FireOwl 19.10.2011 16:46

Ответ: Странное.
 
У левого здоровецкие материки выходят. А у правого архипелаги. Каждый хорош в своем. :-)

dsd 19.10.2011 20:14

Ответ: Странное.
 
Привел шум в более приличный вид и ускорил его до почти приемлемого уровня, но он все равно пока медленней даймонда в size раз.
Цитата:

Код:

Handle perlin_noise(int seed, int size){
srand(seed);
int resolution=1<<size;
//создание структуры данных
float **m1[size];
for(int i=0;i<size;i++){
m1[i]=new float*[resolution];
for(int j=0;j<resolution;j++){m1[i][j]=new float[resolution];}}
//обнуление
for(int i=0;i<size;i++){for(int j=0;j<resolution;j++){for(int k=0;k<resolution;k++){m1[i][j][k]=0;}}}
//создание исходного шума
float length=0;
for(int i=0;i<size;i++){
    int width=1<<(i+1);
        //kof  коэффициент веса октавы
        float kof=(size-i);
        if(i==0){kof=8.01;}
        if(i==1){kof=4.51;}
        if(i==2){kof=2.51;}
        if(i==3){kof=1.01;}
        if(i==4){kof=0.81;}
        if(i==5){kof=0.51;}
        if(i>5){kof=0.24;}
        for(int j=0;j<width;j++){for(int k=0;k<width;k++){m1[i][j<<(size-i-1)][k<<(size-i-1)]=kof*(1-2*(float)rand()/RAND_MAX);}}
        //cуммируется вес октав это будет максимально возможный перепад высот
        length=length+kof;}
//что бы коегде заменить все деления умножением
    float len=(0.5/length);
//тут градиентный шум считается
for(int k=0;k<size-1;k++){
int step=resolution>>1;
while(step>0){
    for(int i=step;i<resolution-step;i=i+2*step){
        for(int j=step;j<resolution-step;j=j+2*step){
        //данные в углах текущей клетки
        float val00=m1[k][i-step][j-step];
        float val01=m1[k][i-step][j+step];
        float val10=m1[k][i+step][j-step];
        float val11=m1[k][i+step][j+step];
        //если текущая клетка пуста, то пишется в клетку крест значений
        if(m1[k][i][j]==0){
        m1[k][i][j]=0.25*(val00+val01+val10+val11);
        m1[k][i-step][j]=0.5*(val00+val01);
        m1[k][i+step][j]=0.5*(val10+val11);
        m1[k][i][j-step]=0.5*(val00+val10);
        m1[k][i][j+step]=0.5*(val01+val11);}
    }}
step=step>>1;}}
//суммирование в последний массив
for(int i=0;i<resolution;i++){for(int j=0;j<resolution;j++){for(int k=0;k<size-1;k++){m1[size-1][i][j]=m1[size-1][i][j]+m1[k][i][j];}m1[size-1][i][j]=(m1[size-1][i][j]+length)*len;}}
//рисование текстуры
Handle tex=xCreateTexture(resolution,resolution);
xSetBuffer(xTextureBuffer(tex));
xLockBuffer(xTextureBuffer(tex));
for (int i=0;i<resolution;i++){
    for (int j=0;j<resolution;j++){
        float val=pow(m1[size-1][i][j],2);
        int red,green,blue;
        if(val<=0.25) {blue=(1-val)*255; green=125*(1-val);red=0;}  //цвет моря
        else {if(val>=0.5) {red=205*val; green=120*val;blue=70;}    //цвет гор
                else{red=255*val; green=255*val;blue=0;}}            //цвет от побережья до предгорий
        xWritePixelFast(i,j,(255<<24)+(red<<16)+(green<<8)+blue,xTextureBuffer(tex));}}
xSetBuffer(xBackBuffer());
xUnlockBuffer(xTextureBuffer(tex));
return tex;}



dsd 20.10.2011 01:00

Ответ: Странное.
 
примерно 30-40% от планируемого класса:rolleyes: фпс 350 при движении по диагонали, ~400 при движении параллельно осям. И сильно снизиться уже не должен:)
Код:

class ground{
//текущая позиция камеры
int x,y;
//***************************************
//меш прикидывающийся детализированным ландшафтам с лодами.
Handle mesh;
//его поверхности ближнего плана
Handle **surf;
//среднего плана
Handle **surfm;
//дальнего плана
// разрешение наиболее детализировнных ячеек.
int resolution;
// разрешение клеток средней детализации
int resol;
int number;
//data for deformations
//хранитель мирового зерна.
int uppersize;
float **seed;
int grain;
//массивы билжнего плана.
float ****strip;
//массивы среднего плана.
float ****stripm;

//шершавость нижнего уровня
float sharpness;
//сглживание
float smothing;
//нижняя точка всего ландшафта
float minimum;
//высота ландшафта
float height;
//******************************************

public:
//конструктор класса
ground(){
    //position intitilazer
    x=xEntityX(Pivot);
    y=xEntityZ(Pivot);
    //Mesh creation
    mesh=xCreateMesh();
    xEntityFX(mesh,2);
    xPositionEntity(mesh,x,0,y);
    //surface for mesh
    //создание ближнего квадрата
    number=6;
    resolution=32;
    sharpness=0.17f;
    smothing=3;
    minimum=1000.4f;
    //ближний план
    surf=new Handle*[number];
    for(int i=0;i<number;i++){surf[i]=new Handle[number];}
    for(int i=0;i<number;i++){for(int j=0;j<number;j++){surf[i][j]=xCreateSurface(mesh);C_Plane(surf[i][j],resolution,resolution*(i-number*0.5f),resolution*(j-number*0.5f));}}

    //генерация мирового зерна
    uppersize=4*128;
    grain=xMillisecs();
    First_Generator(uppersize,5.1f,3,50);
    //структура данных ближнего плана
    strip= new float ***[number+2];
    for(int i=0;i<number+2;i++){strip[i]=new float **[number+2];}
    //генерация деформационных массивов ближнего квадрата.
    for(int i=0;i<number+2;i++){for(int j=0;j<number+2;j++){
    strip[i][j]=new float *[resolution+1];
    for(int k=0;k<=resolution;k++){strip[i][j][k]=new float[resolution+1];}}}
    for(int i=0;i<number+2;i++){for(int j=0;j<number+2;j++){Diamond_Square(i,j,sharpness, smothing);}}
    for(int i=0;i<number;i++){for(int j=0;j<number;j++){Surface_Monolitizer(i,j);}}

    //структура данных среднего плана
    resol=resolution/4;
        //средний план
    surfm=new Handle*[3*number];
    for(int i=0;i<3*number;i++){surfm[i]=new Handle[3*number];}
    for(int i=0;i<3*number;i++){for(int j=0;j<3*number;j++){
      surfm[i][j]=xCreateSurface(mesh);C_Plane_m(surfm[i][j],resol,resolution*(i-1.5f*number),resolution*(j-1.5f*number));
      }}
    stripm= new float ***[3*number+2];
    for(int i=0;i<3*number+2;i++){stripm[i]=new float **[3*number+2];}
    //генерация деформационных массивов ближнего квадрата.
    for(int i=0;i<3*number+2;i++){for(int j=0;j<3*number+2;j++){
    stripm[i][j]=new float *[resol+1];
    for(int k=0;k<=resol;k++){stripm[i][j][k]=new float[resol+1];}}}
    for(int i=0;i<3*number+2;i++){for(int j=0;j<3*number+2;j++){Diamond_Squarem(i,j,sharpness, smothing);}}
    for(int i=0;i<3*number;i++){for(int j=0;j<3*number;j++){Surface_Monolitizerm(i,j);}}
    //*******************************************
    xCalculateFrustumVolume(mesh);
}
//***************************************************
void update(){
    //position intitilazer
    int xc=xEntityX(Pivot);
    int yc=xEntityZ(Pivot);
    if(xc-resolution-1>x){x=x+resolution;Data_Switcher(0);Surface_Switcher(0);Data_Switcherm(0);Surface_Switcherm(0);xCalculateFrustumVolume(mesh);}
    if(xc+resolution+1<x){x=x-resolution;Data_Switcher(1);Surface_Switcher(1);Data_Switcherm(1);Surface_Switcherm(1);xCalculateFrustumVolume(mesh);}
    if(yc-resolution-1>y){y=y+resolution;Data_Switcher(2);Surface_Switcher(2);Data_Switcherm(2);Surface_Switcherm(2);xCalculateFrustumVolume(mesh);}
    if(yc+resolution+1<y){y=y-resolution;Data_Switcher(3);Surface_Switcher(3);Data_Switcherm(3);Surface_Switcherm(3);xCalculateFrustumVolume(mesh);}
    //Создать давилку для среднего под ближним
    //Создать давилку для дальнего под средним

}
//***************************************************
//***************************************************
//***************************************************
void Surface_Monolitizer(int a,int b){

    float m[3][4];
    for(int i=0;i<=resolution;i++){for(int j=0;j<=resolution;j++){
    //вычисляю индекс вершины
    int index=i*(resolution+1)+j;
    //первая нормаль
    int x1=-1; int z1=0;
    int x2=0; int z2=1;
    float y0=strip[a+1][b+1][i][j];
    float y1;
    if(i==0){y1=strip[a][b+1][i+x1+resolution][j+z1];} else{y1=strip[a+1][b+1][i+x1][j+z1];}
    float y2;
    if(j==resolution){y2=strip[a+1][b+2][i+x2][j+z2-resolution];} else{y2=strip[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][0]=y1-y0;
    //y's
    m[1][0]=-1;
    //z's
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resolution){y1=strip[a+1][b+2][i+x1][j+z1-resolution];} else{y1=strip[a+1][b+1][i+x1][j+z1];}
    if(i==resolution){y2=strip[a+2][b+1][i+x2-resolution][j+z2];} else{y2=strip[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][1]=y0-y2;
    //y's
    m[1][1]=-1;
    //z's
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resolution) {y1=strip[a+2][b+1][i+x1-resolution][j+z1];} else{y1=strip[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=strip[a+1][b][i+x2][j+z2+resolution];} else{y2=strip[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][2]=y0-y1;
    //y's
    m[1][2]=-1;
    //z's
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=strip[a+1][b][i+x1][j+z1+resolution];} else{y1=strip[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=strip[a][b+1][i+x2+resolution][j+z2];} else{y2=strip[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][3]=y2-y0;
    //y's
    m[1][3]=-1;
    //z's
    m[2][3]=y1-y0;
    m[0][0]=-0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.25f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=-0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);
    //вершино переставлялко
    //*****************************
    if(y0>=0){xVertexCoords(surf[a][b],index,xVertexX(surf[a][b],index),y0*y0*0.03f,xVertexZ(surf[a][b],index));}
    if(y0<0){xVertexCoords(surf[a][b],index,xVertexX(surf[a][b],index),-y0*y0*0.03f,xVertexZ(surf[a][b],index));}
    //****************************
    xVertexNormal(surf[a][b],index,m[0][0],m[1][0],m[2][0]);
    xVertexColor(surf[a][b],index,127,89,63);
    //*******************************************
    //раскрас поверхности
    //*******************************************
    //y0=y0*3;
    //xVertexColor(surf[a][b],index,y0,y0+70,y0-70);
    //морское дно глубже 2
    if(y0<=-2){xVertexColor(surf[a][b],index,95,75,55);}

    //песок 255,255,125 на побережье
    if(fabs(y0)<2){xVertexColor(surf[a][b],index,255,238+xRnd(-15,15),89+xRnd(-15,15));}
    if(y0>=2 && y0<5){xVertexColor(surf[a][b],index,192+xRnd(-15,15),255,109+xRnd(-15,15));}
    if(y0>=5+xRnd(-0.5,0.5) && y0<10+xRnd(-1,1)){xVertexColor(surf[a][b],index,100+xRnd(-15,15),255,63+xRnd(-15,15));}
    if(y0>=10+xRnd(-1,1) && y0<60+xRnd(-1,1)){xVertexColor(surf[a][b],index,0+xRnd(-15,15),127+xRnd(-15,15),40+xRnd(-15,15));}
    //снег на двадцать единиц ниже пиков
    if(y0>90+xRnd(-3,3)){xVertexColor(surf[a][b],index,255,255,255);}
    }}


}
//***************************************************
void Surface_Monolitizerm(int a,int b){

    float m[3][4];
    for(int i=0;i<=resol;i++){for(int j=0;j<=resol;j++){
    //вычисляю индекс вершины
    int index=i*(resol+1)+j;
    //первая нормаль
    int x1=-1; int z1=0;
    int x2=0; int z2=1;
    float y0=stripm[a+1][b+1][i][j];
    //вершино переставлялко
    //*****************************
    int delta=0;

    if(y0>=0){xVertexCoords(surfm[a][b],index,xVertexX(surfm[a][b],index),y0*y0*0.03f,xVertexZ(surfm[a][b],index));}
    if(y0<0){xVertexCoords(surfm[a][b],index,xVertexX(surfm[a][b],index),-y0*y0*0.03f,xVertexZ(surfm[a][b],index));}
    //если a>
    float y1;
    if(i==0){y1=stripm[a][b+1][i+x1+resol][j+z1];} else{y1=stripm[a+1][b+1][i+x1][j+z1];}
    float y2;
    if(j==resol){y2=stripm[a+1][b+2][i+x2][j+z2-resol];} else{y2=stripm[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][0]=y1-y0;
    //y's
    m[1][0]=-1;
    //z's
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resol){y1=stripm[a+1][b+2][i+x1][j+z1-resol];} else{y1=stripm[a+1][b+1][i+x1][j+z1];}
    if(i==resol){y2=stripm[a+2][b+1][i+x2-resol][j+z2];} else{y2=stripm[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][1]=y0-y2;
    //y's
    m[1][1]=-1;
    //z's
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resol) {y1=stripm[a+2][b+1][i+x1-resol][j+z1];} else{y1=stripm[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=stripm[a+1][b][i+x2][j+z2+resol];} else{y2=stripm[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][2]=y0-y1;
    //y's
    m[1][2]=-1;
    //z's
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=stripm[a+1][b][i+x1][j+z1+resol];} else{y1=stripm[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=stripm[a][b+1][i+x2+resol][j+z2];} else{y2=stripm[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][3]=y2-y0;
    //y's
    m[1][3]=-1;
    //z's
    m[2][3]=y1-y0;
    m[0][0]=-0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.25f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=-0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    //****************************
    xVertexNormal(surfm[a][b],index,m[0][0],m[1][0],m[2][0]);
    xVertexColor(surfm[a][b],index,127,89,63);
    //*******************************************
    //раскрас поверхности
    //*******************************************
    //y0=y0*3;
    //xVertexColor(surf[a][b],index,y0,y0+70,y0-70);
    //морское дно глубже 2
    if(y0<=-2){xVertexColor(surfm[a][b],index,95,75,55);}

    //песок 255,255,125 на побережье
    if(fabs(y0)<2){xVertexColor(surfm[a][b],index,255,238+xRnd(-15,15),89+xRnd(-15,15));}
    if(y0>=2 && y0<5){xVertexColor(surfm[a][b],index,192+xRnd(-15,15),255,109+xRnd(-15,15));}
    if(y0>=5+xRnd(-0.5,0.5) && y0<10+xRnd(-1,1)){xVertexColor(surfm[a][b],index,100+xRnd(-15,15),255,63+xRnd(-15,15));}
    if(y0>=10+xRnd(-1,1) && y0<60+xRnd(-1,1)){xVertexColor(surfm[a][b],index,0+xRnd(-15,15),127+xRnd(-15,15),40+xRnd(-15,15));}
    //снег на двадцать единиц ниже пиков
    if(y0>90+xRnd(-3,3)){xVertexColor(surfm[a][b],index,255,255,255);}
    }}


}

//****************************************
void Data_Switcher(int flag){

float **temp[number+2];
//do not touch this, never ever.
    if(flag==0){
        for(int i=0;i<number+2;i++){
            temp[i]=strip[0][i];
                for(int k=0;k<number+1;k++) {strip[k][i]=strip[k+1][i];}
                strip[number+1][i]=temp[i];
                Diamond_Square(number+1,i,sharpness,smothing);}}
    if(flag==1){
        for(int i=0;i<number+2;i++){
            temp[i]=strip[number+1][i];
                for(int k=number+1;k>0;k--) {strip[k][i]=strip[k-1][i];}
                strip[0][i]=temp[i];
                Diamond_Square2(0,i,sharpness,smothing);}}
    if(flag==2){
        for(int i=0;i<number+2;i++){
            temp[i]=strip[i][0];
                for(int k=0;k<number+1;k++) {strip[i][k]=strip[i][k+1];}
                strip[i][number+1]=temp[i];
                Diamond_Square(i,number+1,sharpness,smothing);}}
    if(flag==3){
        for(int i=0;i<number+2;i++){
            temp[i]=strip[i][number+1];
                for(int k=number+1;k>0;k--) {strip[i][k]=strip[i][k-1];}
                strip[i][0]=temp[i];
                Diamond_Square3(i,0,sharpness,smothing);}}

}
//*******************************************
void Data_Switcherm(int flag){

float **temp[3*number+2];
//do not touch this, never ever.
    if(flag==0){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[0][i];
                for(int k=0;k<3*number+1;k++) {stripm[k][i]=stripm[k+1][i];}
                stripm[3*number+1][i]=temp[i];
                Diamond_Squarem(3*number+1,i,sharpness,smothing);}}
    if(flag==1){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[3*number+1][i];
                for(int k=3*number+1;k>0;k--) {stripm[k][i]=stripm[k-1][i];}
                stripm[0][i]=temp[i];
                Diamond_Square2m(0,i,sharpness,smothing);}}
    if(flag==2){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[i][0];
                for(int k=0;k<3*number+1;k++) {stripm[i][k]=stripm[i][k+1];}
                stripm[i][3*number+1]=temp[i];
                Diamond_Squarem(i,3*number+1,sharpness,smothing);}}
    if(flag==3){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[i][3*number+1];
                for(int k=3*number+1;k>0;k--) {stripm[i][k]=stripm[i][k-1];}
                stripm[i][0]=temp[i];
                Diamond_Square3m(i,0,sharpness,smothing);}}

}

//****************************************
void Surface_Switcher(int flag){
//do not touch this, never ever.
    Handle temp[number];
    if(flag==0){ for(int i=0;i<number;i++){temp[i]=surf[0][i];
    for(int k=0;k<number-1;k++) {surf[k][i]=surf[k+1][i];}
      surf[number-1][i]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j)+number*resolution,xVertexY(temp[i],j),xVertexZ(temp[i],j));}}
        for(int i=0;i<number;i++){Surface_Monolitizer(number-1,i);}}

    if(flag==1){ for(int i=0;i<number;i++){temp[i]=surf[number-1][i];
    for(int k=number-1;k>0;k--) {surf[k][i]=surf[k-1][i];}
    surf[0][i]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j)-number*resolution,xVertexY(temp[i],j),xVertexZ(temp[i],j));}}
        for(int i=0;i<number;i++){
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            Surface_Monolitizer(0,i);}}

    if(flag==2){ for(int i=0;i<number;i++){temp[i]=surf[i][0];
    for(int k=0;k<number-1;k++) {surf[i][k]=surf[i][k+1];}
      surf[i][number-1]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j),xVertexY(temp[i],j),xVertexZ(temp[i],j)+number*resolution);}}
        for(int i=0;i<number;i++){Surface_Monolitizer(i,number-1);}}

    if(flag==3){ for(int i=0;i<number;i++){temp[i]=surf[i][number-1];
    for(int k=number-1;k>0;k--) {surf[i][k]=surf[i][k-1];}
    surf[i][0]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j),xVertexY(temp[i],j),xVertexZ(temp[i],j)-number*resolution);}}
        for(int i=0;i<number;i++){
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
          Surface_Monolitizer(i,0);}}
}
//****************************************
void Surface_Switcherm(int flag){
//do not touch this, never ever.
    Handle temp[3*number];
    if(flag==0){ for(int i=0;i<3*number;i++){temp[i]=surfm[0][i];
    for(int k=0;k<3*number-1;k++) {surfm[k][i]=surfm[k+1][i];}
      surfm[3*number-1][i]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j)+3*number*resolution,xVertexY(temp[i],j),xVertexZ(temp[i],j));}}
        for(int i=0;i<3*number;i++){Surface_Monolitizerm(3*number-1,i);}}

    if(flag==1){ for(int i=0;i<3*number;i++){temp[i]=surfm[3*number-1][i];
    for(int k=3*number-1;k>0;k--) {surfm[k][i]=surfm[k-1][i];}
    surfm[0][i]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j)-3*number*resolution,xVertexY(temp[i],j),xVertexZ(temp[i],j));}}
        for(int i=0;i<3*number;i++){
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            Surface_Monolitizerm(0,i);}}

    if(flag==2){ for(int i=0;i<3*number;i++){temp[i]=surfm[i][0];
    for(int k=0;k<3*number-1;k++) {surfm[i][k]=surfm[i][k+1];}
      surfm[i][3*number-1]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j),xVertexY(temp[i],j),xVertexZ(temp[i],j)+3*number*resolution);}}
        for(int i=0;i<3*number;i++){Surface_Monolitizerm(i,3*number-1);}}

    if(flag==3){ for(int i=0;i<3*number;i++){temp[i]=surfm[i][3*number-1];
    for(int k=3*number-1;k>0;k--) {surfm[i][k]=surfm[i][k-1];}
    surfm[i][0]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j),xVertexY(temp[i],j),xVertexZ(temp[i],j)-3*number*resolution);}}
        for(int i=0;i<3*number;i++){
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
          Surface_Monolitizerm(i,0);}}
}

//---------------------------------------------------
Handle C_Plane(Handle surf,int resolution, int posx, int posy){
    for(int i=0;i<=resolution;i++){for(int j=0;j<=resolution;j++){int v0=xAddVertex(surf,i+posx,0,j+posy,i+posx,j+posy);xVertexNormal(surf,v0,0,1,0);}}
    int qvert=xCountVertices(surf);
    for(int i=0;i<qvert-resolution-1;i++){int v0=i; int v1=i+1; int v2=i+resolution+1; int v3=v2+1;
    if(v3<qvert && xMod(i,resolution+1)!=resolution){xAddTriangle(surf,v2,v1,v3); xAddTriangle(surf,v2,v0,v1);}}
    return surf;}
//----------------------------------------------------
Handle C_Plane_m(Handle surf,int resol, int posx, int posy){
    for(int i=0;i<=resol;i++){for(int j=0;j<=resol;j++){int v0=xAddVertex(surf,i*4+posx,0,j*4+posy,i*4+posx,j*4+posy);xVertexNormal(surf,v0,0,1,0);}}
    int qvert=xCountVertices(surf);
    for(int i=0;i<qvert-resol-1;i++){int v0=i; int v1=i+1; int v2=i+resol+1; int v3=v2+1;
    if(v3<qvert && xMod(i,resol+1)!=resol){xAddTriangle(surf,v2,v1,v3); xAddTriangle(surf,v2,v0,v1);}}
    return surf;}
//---------------------------------------------------

//----------------------------------------------------

//*******************************************************
void Diamond_Square(int a,int b, float sharp, int diff){
int size=resolution;
for(int i=0;i<=size;i++){
    for(int j=0;j<=size;j++){
        strip[a][b][i][j]=0;
        }
    }

//зерно
srand(seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)]);
//боковая и нижняя строки.

for(int i=0;i<=size;i++){
        if(a>0){strip[a][b][0][i]=strip[a-1][b][size][i];}
        if(b>0){strip[a][b][i][0]=strip[a][b-1][i][size];}
}

//заполнение краев
if(strip[a][b][0][0]==0){ strip[a][b][0][0]=seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)];}
if(strip[a][b][size][0]==0) {strip[a][b][size][0]=seed[xMod(x/resolution+a+1,uppersize)][xMod(y/resolution+b,uppersize)];}
if(strip[a][b][0][size]==0) {strip[a][b][0][size]=seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b+1,uppersize)];}
if(strip[a][b][size][size]==0) {strip[a][b][size][size]=seed[xMod(x/resolution+a+1,uppersize)][xMod(y/resolution+b+1,uppersize)];}

int step=size>>1;
while(step>0){
    //первая строка
    for(int i=step;i<=size-step;i=i+2*step){
        for(int j=step;j<=size-step;j=j+2*step){

        float val00=strip[a][b][i-step][j-step];
        float val01=strip[a][b][i-step][j+step];
        float val10=strip[a][b][i+step][j-step];
        float val11=strip[a][b][i+step][j+step];

        if(strip[a][b][i][j]==0){strip[a][b][i][j]=0.25f*(val00+val01+val10+val11)+step*xRnd(-sharp,sharp);}
        if(strip[a][b][i-step][j]==0){strip[a][b][i-step][j]=0.5f*(val00+val01+step*xRnd(-sharp,sharp));}
        if(strip[a][b][i+step][j]==0){strip[a][b][i+step][j]=0.5f*(val10+val11+step*xRnd(-sharp,sharp));}
        if(strip[a][b][i][j-step]==0){strip[a][b][i][j-step]=0.5f*(val00+val10+step*xRnd(-sharp,sharp));}
        if(strip[a][b][i][j+step]==0){strip[a][b][i][j+step]=0.5f*(val01+val11+step*xRnd(-sharp,sharp));}
        }
    }
step=step>>1;}

}
//********************************************************
void Diamond_Square2(int a,int b, float sharp, int diff){
int size=resolution;
for(int i=0;i<=size;i++){
    for(int j=0;j<=size;j++){
        strip[a][b][i][j]=0;
        }
    }

//зерно
srand(seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)]);
//боковая и нижняя строки.

for(int i=0;i<=size;i++){
        if(a<number){strip[a][b][size][i]=strip[a+1][b][0][i];}
        if(b>0){strip[a][b][i][0]=strip[a][b-1][i][size];}
}

//заполнение краев
if(strip[a][b][0][0]==0){ strip[a][b][0][0]=seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)];}
if(strip[a][b][size][0]==0) {strip[a][b][size][0]=seed[xMod(x/resolution+a+1,uppersize)][xMod(y/resolution+b,uppersize)];}
if(strip[a][b][0][size]==0) {strip[a][b][0][size]=seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b+1,uppersize)];}
if(strip[a][b][size][size]==0) {strip[a][b][size][size]=seed[xMod(x/resolution+a+1,uppersize)][xMod(y/resolution+b+1,uppersize)];}

int step=size>>1;
while(step>0){
    //первая строка
    for(int i=step;i<=size-step;i=i+2*step){
        for(int j=step;j<=size-step;j=j+2*step){

        float val00=strip[a][b][i-step][j-step];
        float val01=strip[a][b][i-step][j+step];
        float val10=strip[a][b][i+step][j-step];
        float val11=strip[a][b][i+step][j+step];

        if(strip[a][b][i][j]==0){strip[a][b][i][j]=0.25f*(val00+val01+val10+val11)+step*xRnd(-sharp,sharp);}
        if(strip[a][b][i-step][j]==0){strip[a][b][i-step][j]=0.5f*(val00+val01+step*xRnd(-sharp,sharp));}
        if(strip[a][b][i+step][j]==0){strip[a][b][i+step][j]=0.5f*(val10+val11+step*xRnd(-sharp,sharp));}
        if(strip[a][b][i][j-step]==0){strip[a][b][i][j-step]=0.5f*(val00+val10+step*xRnd(-sharp,sharp));}
        if(strip[a][b][i][j+step]==0){strip[a][b][i][j+step]=0.5f*(val01+val11+step*xRnd(-sharp,sharp));}
        }
    }
step=step>>1;}

}
//********************************************************
void Diamond_Square3(int a,int b, float sharp, int diff){
int size=resolution;
for(int i=0;i<=size;i++){
    for(int j=0;j<=size;j++){
        strip[a][b][i][j]=0;
        }
    }

//зерно
srand(seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)]);
//боковая и нижняя строки.

for(int i=0;i<=size;i++){
        if(a>0){strip[a][b][0][i]=strip[a-1][b][size][i];}
        if(b<number){strip[a][b][i][size]=strip[a][b+1][i][0];}
}

//заполнение краев
if(strip[a][b][0][0]==0){ strip[a][b][0][0]=seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)];}
if(strip[a][b][size][0]==0) {strip[a][b][size][0]=seed[xMod(x/resolution+a+1,uppersize)][xMod(y/resolution+b,uppersize)];}
if(strip[a][b][0][size]==0) {strip[a][b][0][size]=seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b+1,uppersize)];}
if(strip[a][b][size][size]==0) {strip[a][b][size][size]=seed[xMod(x/resolution+a+1,uppersize)][xMod(y/resolution+b+1,uppersize)];}

int step=size>>1;
while(step>0){
    //первая строка
    for(int i=step;i<=size-step;i=i+2*step){
        for(int j=step;j<=size-step;j=j+2*step){

        float val00=strip[a][b][i-step][j-step];
        float val01=strip[a][b][i-step][j+step];
        float val10=strip[a][b][i+step][j-step];
        float val11=strip[a][b][i+step][j+step];

        if(strip[a][b][i][j]==0){strip[a][b][i][j]=0.25f*(val00+val01+val10+val11)+step*xRnd(-sharp,sharp);}
        if(strip[a][b][i-step][j]==0){strip[a][b][i-step][j]=0.5f*(val00+val01+step*xRnd(-sharp,sharp));}
        if(strip[a][b][i+step][j]==0){strip[a][b][i+step][j]=0.5f*(val10+val11+step*xRnd(-sharp,sharp));}
        if(strip[a][b][i][j-step]==0){strip[a][b][i][j-step]=0.5f*(val00+val10+step*xRnd(-sharp,sharp));}
        if(strip[a][b][i][j+step]==0){strip[a][b][i][j+step]=0.5f*(val01+val11+step*xRnd(-sharp,sharp));}
        }
    }
step=step>>1;}

}

//*-**-*-*-*-*--*-*-*-*-*-*
//*******************************************************
void Diamond_Squarem(int a,int b, float sharp, int diff){
int size=resol;
for(int i=0;i<=size;i++){
    for(int j=0;j<=size;j++){
        stripm[a][b][i][j]=0;
        }
    }

//зерно
//srand(seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)]);
srand(seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b-number,uppersize)]);
//боковая и нижняя строки.

for(int i=0;i<=size;i++){
        if(a>0){stripm[a][b][0][i]=stripm[a-1][b][size][i];}
        if(b>0){stripm[a][b][i][0]=stripm[a][b-1][i][size];}
}

//заполнение краев
if(stripm[a][b][0][0]==0){ stripm[a][b][0][0]=seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b-number,uppersize)];}
if(stripm[a][b][size][0]==0) {stripm[a][b][size][0]=seed[xMod(x/resolution+a+1-number,uppersize)][xMod(y/resolution+b-number,uppersize)];}
if(stripm[a][b][0][size]==0) {stripm[a][b][0][size]=seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b+1-number,uppersize)];}
if(stripm[a][b][size][size]==0) {stripm[a][b][size][size]=seed[xMod(x/resolution+a+1-number,uppersize)][xMod(y/resolution+b+1-number,uppersize)];}

int step=size>>1;
while(step>0){
    //первая строка
    for(int i=step;i<=size-step;i=i+2*step){
        for(int j=step;j<=size-step;j=j+2*step){

        float val00=stripm[a][b][i-step][j-step];
        float val01=stripm[a][b][i-step][j+step];
        float val10=stripm[a][b][i+step][j-step];
        float val11=stripm[a][b][i+step][j+step];

        if(stripm[a][b][i][j]==0){stripm[a][b][i][j]=0.25f*(val00+val01+val10+val11)+step*xRnd(-sharp,sharp);}
        if(stripm[a][b][i-step][j]==0){stripm[a][b][i-step][j]=0.5f*(val00+val01+step*xRnd(-sharp,sharp));}
        if(stripm[a][b][i+step][j]==0){stripm[a][b][i+step][j]=0.5f*(val10+val11+step*xRnd(-sharp,sharp));}
        if(stripm[a][b][i][j-step]==0){stripm[a][b][i][j-step]=0.5f*(val00+val10+step*xRnd(-sharp,sharp));}
        if(stripm[a][b][i][j+step]==0){stripm[a][b][i][j+step]=0.5f*(val01+val11+step*xRnd(-sharp,sharp));}
        }
    }
step=step>>1;}

}
//********************************************************
void Diamond_Square2m(int a,int b, float sharp, int diff){
int size=resol;
for(int i=0;i<=size;i++){
    for(int j=0;j<=size;j++){
        stripm[a][b][i][j]=0;
        }
    }

//зерно
srand(seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b-number,uppersize)]);
//боковая и нижняя строки.

for(int i=0;i<=size;i++){
        if(a<number){stripm[a][b][size][i]=stripm[a+1][b][0][i];}
        if(b>0){stripm[a][b][i][0]=stripm[a][b-1][i][size];}
}

//заполнение краев
if(stripm[a][b][0][0]==0){ stripm[a][b][0][0]=seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b-number,uppersize)];}
if(stripm[a][b][size][0]==0) {stripm[a][b][size][0]=seed[xMod(x/resolution+a+1-number,uppersize)][xMod(y/resolution+b-number,uppersize)];}
if(stripm[a][b][0][size]==0) {stripm[a][b][0][size]=seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b+1-number,uppersize)];}
if(stripm[a][b][size][size]==0) {stripm[a][b][size][size]=seed[xMod(x/resolution+a+1-number,uppersize)][xMod(y/resolution+b+1-number,uppersize)];}

int step=size>>1;
while(step>0){
    //первая строка
    for(int i=step;i<=size-step;i=i+2*step){
        for(int j=step;j<=size-step;j=j+2*step){

        float val00=stripm[a][b][i-step][j-step];
        float val01=stripm[a][b][i-step][j+step];
        float val10=stripm[a][b][i+step][j-step];
        float val11=stripm[a][b][i+step][j+step];

        if(stripm[a][b][i][j]==0){stripm[a][b][i][j]=0.25f*(val00+val01+val10+val11)+step*xRnd(-sharp,sharp);}
        if(stripm[a][b][i-step][j]==0){stripm[a][b][i-step][j]=0.5f*(val00+val01+step*xRnd(-sharp,sharp));}
        if(stripm[a][b][i+step][j]==0){stripm[a][b][i+step][j]=0.5f*(val10+val11+step*xRnd(-sharp,sharp));}
        if(stripm[a][b][i][j-step]==0){stripm[a][b][i][j-step]=0.5f*(val00+val10+step*xRnd(-sharp,sharp));}
        if(stripm[a][b][i][j+step]==0){stripm[a][b][i][j+step]=0.5f*(val01+val11+step*xRnd(-sharp,sharp));}
        }
    }
step=step>>1;}

}
//********************************************************
void Diamond_Square3m(int a,int b, float sharp, int diff){
int size=resol;
for(int i=0;i<=size;i++){
    for(int j=0;j<=size;j++){
        stripm[a][b][i][j]=0;
        }
    }

//зерно
srand(seed[xMod(x/resol+a-number,uppersize)][xMod(y/resol+b-number,uppersize)]);
//боковая и нижняя строки.

for(int i=0;i<=size;i++){
        if(a>0){stripm[a][b][0][i]=stripm[a-1][b][size][i];}
        if(b<number){stripm[a][b][i][size]=stripm[a][b+1][i][0];}
}

//заполнение краев
if(stripm[a][b][0][0]==0){ stripm[a][b][0][0]=seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b-number,uppersize)];}
if(stripm[a][b][size][0]==0) {stripm[a][b][size][0]=seed[xMod(x/resolution+a+1-number,uppersize)][xMod(y/resolution+b-number,uppersize)];}
if(stripm[a][b][0][size]==0) {stripm[a][b][0][size]=seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b+1-number,uppersize)];}
if(stripm[a][b][size][size]==0) {stripm[a][b][size][size]=seed[xMod(x/resolution+a+1-number,uppersize)][xMod(y/resolution+b+1-number,uppersize)];}

int step=size>>1;
while(step>0){
    //первая строка
    for(int i=step;i<=size-step;i=i+2*step){
        for(int j=step;j<=size-step;j=j+2*step){

        float val00=stripm[a][b][i-step][j-step];
        float val01=stripm[a][b][i-step][j+step];
        float val10=stripm[a][b][i+step][j-step];
        float val11=stripm[a][b][i+step][j+step];

        if(stripm[a][b][i][j]==0){stripm[a][b][i][j]=0.25f*(val00+val01+val10+val11)+step*xRnd(-sharp,sharp);}
        if(stripm[a][b][i-step][j]==0){stripm[a][b][i-step][j]=0.5f*(val00+val01+step*xRnd(-sharp,sharp));}
        if(stripm[a][b][i+step][j]==0){stripm[a][b][i+step][j]=0.5f*(val10+val11+step*xRnd(-sharp,sharp));}
        if(stripm[a][b][i][j-step]==0){stripm[a][b][i][j-step]=0.5f*(val00+val10+step*xRnd(-sharp,sharp));}
        if(stripm[a][b][i][j+step]==0){stripm[a][b][i][j+step]=0.5f*(val01+val11+step*xRnd(-sharp,sharp));}
        }
    }
step=step>>1;}

}
//********************************************************
float xRnd(float min, float max){
    float length=max-min;
    float var =((float) rand() / (float)RAND_MAX);
    float value=min+var*length;
return value;}
//********************************************************
void First_Generator(int size, float sharp, int diff , int height){
float max=-10000.01;
srand(grain);
//создается массив для значений
seed=new float*[size+1];
for(int i=0;i<=size;i++){
    seed[i]= new float[size+1];
}
for(int i=0;i<=size;i++){
    for(int j=0;j<=size;j++){
        seed[i][j]=0;
        }
    }

for(int i=0;i<=size;i=i+(size>>2)){
    for(int j=0;j<=size;j=j+(size>>2)){
        seed[i][j]=xRnd(-height,height);
        }
    }
int step=size>>1;
while(step>0){
    //первая строка
    for(int i=step;i<=size-step;i=i+2*step){
        for(int j=step;j<=size-step;j=j+2*step){

        float val00=seed[i-step][j-step];
        float val01=seed[i-step][j+step];
        float val10=seed[i+step][j-step];
        float val11=seed[i+step][j+step];

        if(seed[i][j]==0 && val00!=0 && val01!=0 && val10!=0 && val11!=0){seed[i][j]=0.25*(val00+val01+val10+val11)+step*xRnd(-sharp,sharp);}
        if(seed[i-step][j]==0 && val00!=0 && val01!=0){seed[i-step][j]=0.5*(val00+val01)+0.5*step*xRnd(-sharp,sharp);}
        if(seed[i+step][j]==0 && val10!=0 && val11!=0){seed[i+step][j]=0.5*(val10+val11)+0.5*step*xRnd(-sharp,sharp);}
        if(seed[i][j-step]==0 && val00!=0 && val10!=0){seed[i][j-step]=0.5*(val00+val10)+0.5*step*xRnd(-sharp,sharp);}
        if(seed[i][j+step]==0 && val01!=0 && val11!=0){seed[i][j+step]=0.5*(val01+val11)+0.5*step*xRnd(-sharp,sharp);}
        }
    }
step=step>>1;

}
for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){
        if(seed[i][j]<minimum){minimum=seed[i][j];}
        if(seed[i][j]>max){max=seed[i][j];}
    }}
    height=max-minimum;


}
//********************************************************
int xMod(int a,int b){
int c=a-b*floor(a/b);
if(c<0) {c=c+b;}
return c;
}
//********************************************************
};


impersonalis 20.10.2011 01:10

Ответ: Странное.
 
Мне почему-то кажется, что код можно неплохо укоротить, если использовать (написать) библиотеку для работы с матрицами с адекватным интерфейсом (перегруженные операторы = * и прочее).
Но, возможно, только кажется

moka 20.10.2011 03:14

Ответ: Странное.
 
Да, быстр пробегаясь по коду, замечаешь симетрии и шаблоны, значит можно вывезти в отдельные мелкие рутины и использовать их.

pozitiffcat 20.10.2011 09:10

Ответ: Странное.
 
Цитата:

Сообщение от impersonalis (Сообщение 206366)
Мне почему-то кажется, что код можно неплохо укоротить, если использовать (написать) библиотеку для работы с матрицами с адекватным интерфейсом (перегруженные операторы = * и прочее).
Но, возможно, только кажется

А я давно предлагал почитать книгу =) столько бы проблем решилось :rolleyes:

dsd 20.10.2011 10:33

Ответ: Странное.
 
А мне кажется для ~100 часов опытов в с++ не такой уж и ужасный код :)

Перегрузку операторов, всякие там виртуальные функции, наследование, шаблоны и т.д. я еще не пробовал, но планирую освоить.

И да, дьявол кроется в деталях. Может смещения и получится унифицировать как получилось объединить деформацию и обновление нормалей, но вряд ли там довольно разные вещи в зависимости от направления происходят.

dsd 20.10.2011 18:59

Ответ: Странное.
 
Почему имя переменной far пугает компилятор? O_o

pozitiffcat 20.10.2011 19:08

Ответ: Странное.
 
Цитата:

Сообщение от dsd (Сообщение 206383)
виртуальные функции

освой обязательно, незаменимая вещь

dsd 20.10.2011 20:42

Ответ: Странное.
 

Маленькая демка. С небольшим уровнем детализации. от камеры ландшафт рисуется где-то на 1500 единиц
36 частиц 32х32. Можно критиковать, но имейте в виду в моем проекте не предполагается летать :)

Высокий уровень детализации 100 частиц 128х128 от камеры рисуется тыщь на десять.

FireOwl 20.10.2011 21:45

Ответ: Странное.
 
Неплохо. Стыки бы еще как-нибудь замазать.

P.S. Кулер на видеокарте зашумел. Работало шустро, никаких глюков.
Но через минуту вылетело с "Драйвер видеокарты бла-бла-бла и был восстановлен." У меня все сейчас так вылетает, начиная с Майнкрафта. Хотя и не так быстро.

h1dd3n 20.10.2011 21:58

Ответ: Странное.
 
Цитата:

Сообщение от FireOwl (Сообщение 206423)
Неплохо. Стыки бы еще как-нибудь замазать.

P.S. Кулер на видеокарте зашумел. Работало шустро, никаких глюков.
Но через минуту вылетело с "Драйвер видеокарты бла-бла-бла и был восстановлен." У меня все сейчас так вылетает, начиная с Майнкрафта. Хотя и не так быстро.


проверь на перегрев

FireOwl 20.10.2011 22:22

Ответ: Странное.
 
По теме: еще берега "дрожат" сильно.


Не по теме, за что извиняюсь. :-)
Перегрев - первое, что приходит в голову. И наверное, сейчас виноват именно он.
Но проблема существует независимо. Обычно все вылетает при температуре Gpu около 56 градусов. И эта температура ничем не отличается от той, при которой все работало уже пол-часа.
Замеряю Aida64 (бывший Everest). Может врет?

Upd:
Переношу оффтоп на законную почву сюда: http://forum.boolean.name/showthread...430#post206430

dsd 20.10.2011 23:53

Ответ: Странное.
 
Цитата:

Сообщение от FireOwl (Сообщение 206427)
По теме: еще берега "дрожат" сильно.

Это исправится с заменой фрактального генератора шума на перлин.

Ну а вылетело быстрей из=за того, что я отрубил vsynk, а на слабых видеокартах результат деформаций рисуется дольше, чем происходит их расчет и манипуляции с моделями. Соответственно видеокарта работала на все 100%.

Я заметил странную вещь.

Создание объекта моего класса занимает заметное на глаз время, и в окне приложения я вижу постепенное выполнение конструктора. Но из структуры программы объект должен быть сначала полностью создан и только затем запустится главный цикл, где есть команда рендервурлд. Это что получается мой компилятор умудряется делить мой код на потоки, когда я большую часть вычислений впихиваю в класс? И почему оно не рушится когда обращается к еще не существующим данным в классе при апдейте. Что это за неведомая мистическая херня происходит? Сам хорс же не причем ведь?

impersonalis 21.10.2011 00:33

Ответ: Странное.
 
Цитата:

Сообщение от dsd (Сообщение 206383)
но вряд ли там довольно разные вещи в зависимости от направления происходят.

Возможно, вы недооцениваете матричные операторы: меняя всего-лишь коэффициенты можно добиться различных преобразований изображения, или изменений позиции\ориентации объектов, например.
Если вы считаете себя новичком в ЯП, то, возможно, не стоит начинать решать задачи, теоретическую подоплёку которых вы также собираетесь взять нахрапом.
Хотя, с другой стороны, такой подход (в условиях информационной изоляции), я думаю, мне, в своё время, не помешал. Но у вас: есть и-нет, и, наверняка, нет желания тратить время на велик - так что, наверное, стоит чуть подтянуть теорию. И дело не только в математике, и не столько в абстракциях Си++, сколько в несворачивании, очевидного
Код:

float val00=m1[k][i-step][j-step];
float val01=m1[k][i-step][j+step];
float val10=m1[k][i+step][j-step];
float val11=m1[k][i+step][j+step];

одновременно с ЙоптаЧтоИта-стайлом минимизации кода
Код:

for(int j=0;j<width;j++){for(int k=0;k<width;k++){m1[i][j<<(size-i-1)][k<<(size-i-1)]=kof*(1-2*(float)rand()/RAND_MAX);}}
(отличные имена переменных, форматирование на высоте, очевидные конструкции на битовом сдвиге; кстати, RAND_MAX лучше привести к типу float)
Возможно (весьма вероятно), что я необъективен и попросту ною, подавляя начинающих... Прошу не принимать близко к сердцу
код не читал @ сразу отвечал

dsd 21.10.2011 01:35

Ответ: Странное.
 
В бытность свою студентом стройфака я всегда оптимистично в течении семестра полагал, что: так этот, тот и вот тот предмет с нехилыми курсачами я куплю, и пребывая в полном спокойствии не появлялся ни на лекциях ни на практических занятиях. А затем, внезапно, при неожиданном наступлении зачетной недели выяснялось, что вот эти восемьсот рублей надо растянуть до начала экзаменов(и дело происходит не в общаге, и интернета нет, и писать поясниловку надо от руки, а картинки рисовать от руки по госту пару-тройку а1, а право выполнять все на компе можно было заслужить только истовым навязчивым ботанизмом). А планируемые покупки в бюджет не влазят и кредита никто не даст. Пробовали ли вы когда-нибудь делать курсовую работу не зная даже теории и имея в руках только !неправильный! пример сляпанный каким-то дебилом прошлых лет из нескольких работ? Пробовали ли вы сдать результат враждебно настроенному преподу постепенно осознающему, что вот это перед ним сидящее тело передумало дать ему пару-тройку тыщь? К четвертому курсу я развил навык до уровня сочинения теории из примера расчета :) А как я весело передумал 27 мая заказывать диплом в виду финансовых затруднений. И как я его подписал за три дня до конца срока, и как надо мной ржали преподы на защите, когда выяснилось, что он сделан так, что проходит по всем кафедрам. Эмм... О чем это я? У меня прокачан скилл нахрапа :D.

Насчет великов, лежащие в инете реализация редко иначе как анальными назвать нельзя, это те в которых я по коду могу вообразить, что примерно там происходит. А чаще вся информация сводится к паре рисунков либо примитивного уровня либо художественного.

Возможно я недооцениваю матричные операторы(проще сказать, что я о них не имею представления) Но вполне очевидно, что они(операторы) могут каким-либо(весьма разнообразным) образом изменить существующие данные, но вот превратить нолики в 4 миллиона не повторяющихся набора данных со связанными краями, это вряд ли, я не верю в это.

ЗЫ: Походу никто не осознает что у меня внутри класса происходит на самом деле, ну и ладно.
Кстати как эти матричные операторы можно применить к этому:
Код:

void Surface_Switcherm(int flag){
    Handle temp[3*number];
    if(flag==0){ for(int i=0;i<3*number;i++){temp[i]=surfm[0][i];
    for(int k=0;k<3*number-1;k++) {surfm[k][i]=surfm[k+1][i];}
      surfm[3*number-1][i]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j)+3*number*resolution,xVertexY(temp[i],j),xVertexZ(temp[i],j));}}
        for(int i=0;i<3*number;i++){Surface_Monolitizerm(3*number-1,i);}
        for(int i=number;i<2*number;i++){surfm[number-1][i]=surfm[2*number-1][i];int qvert=xCountVertices(surfm[number-1][i]);
        for(int j=0;j<qvert;j++){xVertexCoords(surfm[number-1][i],j,xVertexX(surfm[number-1][i],j)-number*resolution,xVertexY(surfm[number-1][i],j),xVertexZ(surfm[number-1][i],j));}}
        for(int i=number;i<2*number;i++){Surface_Monolitizerm(number-1,i);}
        }

    if(flag==1){ for(int i=0;i<3*number;i++){temp[i]=surfm[3*number-1][i];
    for(int k=3*number-1;k>0;k--) {surfm[k][i]=surfm[k-1][i];}
    surfm[0][i]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j)-3*number*resolution,xVertexY(temp[i],j),xVertexZ(temp[i],j));}}
        for(int i=0;i<3*number;i++){Surface_Monolitizerm(0,i);}
        for(int i=number;i<2*number;i++){surfm[2*number][i]=surfm[number][i];int qvert=xCountVertices(surfm[2*number][i]);
        for(int j=0;j<qvert;j++){xVertexCoords(surfm[2*number][i],j,xVertexX(surfm[2*number][i],j)+number*resolution,xVertexY(surfm[2*number][i],j),xVertexZ(surfm[2*number][i],j));}}
        for(int i=number;i<2*number;i++){Surface_Monolitizerm(2*number,i);}
        }

    if(flag==2){ for(int i=0;i<3*number;i++){temp[i]=surfm[i][0];
    for(int k=0;k<3*number-1;k++) {surfm[i][k]=surfm[i][k+1];}
      surfm[i][3*number-1]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j),xVertexY(temp[i],j),xVertexZ(temp[i],j)+3*number*resolution);}}
        for(int i=0;i<3*number;i++){Surface_Monolitizerm(i,3*number-1);}
        for(int i=number;i<2*number;i++){surfm[i][number-1]=surfm[i][2*number-1];int qvert=xCountVertices(surfm[i][number-1]);
        for(int j=0;j<qvert;j++){xVertexCoords(surfm[i][number-1],j,xVertexX(surfm[i][number-1],j),xVertexY(surfm[i][number-1],j),xVertexZ(surfm[i][number-1],j)-number*resolution);}}
        for(int i=number;i<2*number;i++){Surface_Monolitizerm(i,number-1);}
        }

    if(flag==3){ for(int i=0;i<3*number;i++){temp[i]=surfm[i][3*number-1];
    for(int k=3*number-1;k>0;k--) {surfm[i][k]=surfm[i][k-1];}
    surfm[i][0]=temp[i];
        int qvert=xCountVertices(temp[i]);
        for(int j=0;j<qvert;j++){xVertexCoords(temp[i],j,xVertexX(temp[i],j),xVertexY(temp[i],j),xVertexZ(temp[i],j)-3*number*resolution);}}
        for(int i=0;i<3*number;i++){Surface_Monolitizerm(i,0);}
        for(int i=number;i<2*number;i++){surfm[i][2*number]=surfm[i][number];int qvert=xCountVertices(surfm[i][2*number]);
        for(int j=0;j<qvert;j++){xVertexCoords(surfm[i][2*number],j,xVertexX(surfm[i][2*number],j),xVertexY(surfm[i][2*number],j),xVertexZ(surfm[i][2*number],j)+number*resolution);}}
        for(int i=number;i<2*number;i++){Surface_Monolitizerm(i,2*number);}
        }
}
void Data_Switcherm(int flag){

float **temp[3*number+2];
    if(flag==0){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[0][i];
                for(int k=0;k<3*number+1;k++) {stripm[k][i]=stripm[k+1][i];}
                stripm[3*number+1][i]=temp[i];
                Diamond_Squarem(3*number+1,i,sharpness,smothing);}}
    if(flag==1){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[3*number+1][i];
                for(int k=3*number+1;k>0;k--) {stripm[k][i]=stripm[k-1][i];}
                stripm[0][i]=temp[i];
                Diamond_Square2m(0,i,sharpness,smothing);}}
    if(flag==2){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[i][0];
                for(int k=0;k<3*number+1;k++) {stripm[i][k]=stripm[i][k+1];}
                stripm[i][3*number+1]=temp[i];
                Diamond_Squarem(i,3*number+1,sharpness,smothing);}}
    if(flag==3){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[i][3*number+1];
                for(int k=3*number+1;k>0;k--) {stripm[i][k]=stripm[i][k-1];}
                stripm[i][0]=temp[i];
                Diamond_Square3m(i,0,sharpness,smothing);}}

}


HolyDel 21.10.2011 02:37

Ответ: Странное.
 
макрос far определен где то в windows.h
не включай сей файл и можно обзывать переменную far. или #undef

impersonalis 21.10.2011 11:00

Ответ: Странное.
 
Цитата:

Пробовали ли вы когда-нибудь делать курсовую работу не зная даже теории и имея в руках только !неправильный! пример сляпанный каким-то дебилом прошлых лет из нескольких работ?
Да. И не раз (как, навреное, каждый студент).
Цитата:

Пробовали ли вы сдать результат враждебно настроенному преподу
Да. Ничего не покупал и на платные доп.курс не ходил, даже если оставались хвосты.
Цитата:

А как я весело передумал 27 мая заказывать диплом в виду финансовых затруднений.
С одной стороны - звучит круто. С другой: покупка диплома это ппц - раз, сводит на нет предшествующие хвальбы - два ( а вот как сдавали предмет на ОТЛ, зная гораздо менее меня, отправляющегося на пересдачу - видел и не раз: вероятно тоже потом считали, что ОТЛ - результат умения разбираться в сложных вещах на пустом месте).

mauNgerS 21.10.2011 13:11

Ответ: Странное.
 
:-DМоя учёба на мехфаке:-D

ПС impersonalis правильно говорит это учёба многих студентов:-D

dsd 21.10.2011 14:22

Ответ: Странное.
 
Самое смешное, что все трудоустроенные по специальности люди дипломы заказли. То есть все кто хоть както разбирался в своей специальности и имел возможность заказать заказали, почему то все поголовно предпочли потратить полгода на получение реальных навыков вместо кучи ритуальных расчетов по доисторическим снипам конструкций, которые теперь считают более вменяемым и автоматизированным образом.

Без проблем подобный образ жизни вести может максимум процентов десять студентов.

moka 21.10.2011 14:26

Ответ: Странное.
 
Дык, система образования всегда отставала от современных разработок и стандартов в индустрии, для которой якобы студенты готовятся.
Те кто работают всё это время которое студент "учится", приобретают намного ценней опыт и знания + копейку.

dsd 21.10.2011 21:28

Ответ: Странное.
 
impersonalis, че O_o?!!!
Что это было? Причем тут правильно не правильно? Тем более правильно или нет человек может сказать только перед тем как склейть ласты.

Зы: Наверно приятно чувствовать себя телепатом, но это патология.

impersonalis 21.10.2011 21:32

Ответ: Странное.
 
Цитата:

Сообщение от MoKa (Сообщение 206470)
Дык, система образования всегда отставала от современных разработок и стандартов в индустрии, для которой якобы студенты готовятся.
Те кто работают всё это время которое студент "учится", приобретают намного ценней опыт и знания + копейку.

неужели есть люди, которые думают, что изучат ЯП, прочитав учебник? Разумеется, надо развиваться и самостоятельно. Однако, благодаря квази-студентам, которые не в состоянии написать диплом, девальвация образования и поддерживается. У меня много примеров студентов, которые работали (в т.ч. и по специальности) и учились (без кавычек). ЧЯДНТ?
Честно говоря, теперь, узнав что автор уже человек с высшим образованием, технарь, не может осилить относительно простую теорию (в которой сам заинтересован - а такая мотивация сдвигает горы), я испытываю батхёрт мне приходит в голову анекдот (изначально он был с полит.подтекстом, но не нашёл оригинала).
http://www.detskie-anekdoty.ru/detsk...po lgoda.html
dsd, умерьте спесь: если б вы были семи пядей во лбу и действительно ценили своё время - вы бы бросили учёбу курсе на первом-втором. А так - гордится тут абсолютно нечем.
Прошу извинить, если обидел. Это сугубо моё мнение. Практика показала, что, разумеется, есть и другие стратегии поведения, но они сопровождаются и другими решениями (типа того, что я привёл: бывает да - ВУЗ не тот выбрал, со специальностью ошибся, недооценил свой интеллект). Думаю, нам всё же пора вернуться к теме обсуждений, а не доказывать друг другу свою крутость.

moka 21.10.2011 21:56

Ответ: Странное.
 
Полностью поддерживаю. Но это аналогично условному "разделению" людей на тех кто может двигаться сам, и тех кому нужны пинки под зад. При этом это не две категории, а некий отрезок, на котором каждый где-то между.
Но к сожалению по моим наблюдениям, большая часть, которая сидит тихо и никого не трогает, студентов, они как раз именно те, кто не имеют никаких целей, учатся, не зная зачем. На те же компьютерные направления идут и то побольше нормальных голов. А вот посмотреть другие отрасли, так там ваще большинство потерянных, нифига не думающий куда, что, зачем и для чего..
Это не абсолютная истина, а лишь частичная, не опровергает твоей, да. А лишь дополняет картинку..

Споров нет. ;)
Везде есть плюсы и минусы. Даже самое захолустное учреждение, даст материал с базой, который очень важен, и который обычно игнорируется и "проскакивается" энтузиастами на началах, потом "жалеют".

dsd 21.10.2011 23:25

Ответ: Странное.
 




pozitiffcat 22.10.2011 00:36

Ответ: Странное.
 
МегаРжычь :offtopic: кстати а куда facepalm делся из смайликов?

dsd 22.10.2011 00:46

Ответ: Странное.
 

Оказывается писать работающие шейдеры не просто, а очень просто. Надо только знать базовый синтаксис с++ или с# и поиграться с вершинами, нормалями до отрастания рефлексов:rolleyes:
Написать красивый шейдер, однако не просто, это тайнство :)

А еще оказывается 540m это слабенькая видеокарта в отношении рисования текстур :)

Reizel 22.10.2011 03:03

Ответ: Странное.
 
http://forum.boolean.name/showpost.p...5&postcount=29
Похвастаюсь)))
Правда водичка дёргаеца слишком быстро - разрабатывалось все на столь маломощном компе, который выдавал приятные колыхания той самой водички)

dsd 22.10.2011 12:54

Ответ: Странное.
 
Цитата:

if(y>=15&&y<=80)return tex2D(s1,tc*20);
if(y<-20) return tex2D(s5,tc*20);
if(y<0) return fAlpha(tex2D(s3,tc*20),tex2D(s5,tc*20),(-y)/20.0f);
if(y<10) return tex2D(s3,tc*20);
if(y<15&&y>=10) return fAlpha(tex2D(s3,tc*20),tex2D(s1,tc*20),(y-10)/5.0f);
if(y>90) return tex2D(s4,tc*20);
if(y>80&&y<=90) return fAlpha(tex2D(s1,tc*20),tex2D(s4,tc*20),(-80+y)*.1);
В общем я сделал тоже самое, только возле границ еще не смешивал текстуры. Зачем ты tex2D(s1,tc*20) на 20 умножаешь?

можно ж проще
Код:

float scale;

void VS_Main_(in VS_INPUT input, out VS_OUTPUT output)

{
        output.position = mul(input.position,matrixWorldViewProj);
        output.worldPosition = input.position;
        output.normal = normalize(mul(input.normal,matrixWorld));
        output.texCoords = scale*input.texCoords;
}

И из хорса подобной строкой все передать:
xSetEffectFloat(first.farmesh,"scale",0.1);

Кстати по моему надо не только от высоты, но и от нормали установить зависимость текстуры. Например если уклон больше 30 градусов то начинается смешивание со скальной текстурой и после ~60 градусов остается уже только текстура скалы без примеси текстуры текущей зоны :)

Reizel 22.10.2011 13:37

Ответ: Странное.
 
Цитата:

Сообщение от dsd (Сообщение 206566)
Кстати по моему надо не только от высоты, но и от нормали установить зависимость текстуры. Например если уклон больше 30 градусов то начинается смешивание со скальной текстурой и после ~60 градусов остается уже только текстура скалы без примеси текстуры текущей зоны :)

Хотел сделать, руки не дошли

dsd 22.10.2011 17:14

Ответ: Странное.
 

Починил нормали, Заменил верхний алгоритм генерации шума на более адекватный, сгладил горизонт, научил шейдер смазывать границы между текстурами. Ужал код класса до 500 строк. Yeahh... Но какой же все таки стремный результат. Надо сочинять продавливатель рек и какой-нибудь генератор растительности.

Код:

else if(input.position2>=21.5f && input.position2<34.5f){
        float4 diffuse = tex2D(lmountainSampler, input.texCoords);
        return diffuse * lit * lightColor;}

else if(input.position2>=34.5f && input.position2<35.5f){
        float4 diffuse1 = tex2D(lmountainSampler, input.texCoords);
        float4 diffuse2 = tex2D(mmountainSampler, input.texCoords);
        float4 diffuse =(input.position2-34.5f)*diffuse2+(35.5f-input.position2)*diffuse1;
        return diffuse * lit * lightColor;}       
       
else if(input.position2>=35.5f && input.position2<49.5f){
        float4 diffuse = tex2D(mmountainSampler, input.texCoords);
        return diffuse * lit * lightColor;}


Reizel 22.10.2011 23:54

Ответ: Странное.
 
Жду генератора растительности, сам пытаюсь сделать)

dsd 23.10.2011 00:59

Ответ: Странное.
 
Ну деревья я еще в бэйсике понял как генерировать алгоритмом l-system, а вот цветочки попробую по алгоритмической ботанике. Главное одной поверхностью обойтись, что бы оно за один дип рисовалось.


Научил шейдер поверхность с наклоном более 40 градусов зарисовывать скалой.
Код:

float4 rock = tex2D(rocknSampler, input.texCoords);
//вычисляю кос угла между нормалью в этой точке и вектором(0,1,0)
float degcos = dot(input.normal,float3(0.0f,1.0f,0.0f));
if (degcos<0.75) {diffuse=rock;}//полная замена текстуры
if (degcos>=0.75 && degcos<0.8) {diffuse=20*(degcos-0.75)*diffuse+20*(0.8-degcos)*rock;}//смешивание с основной текстурой по краям

float4 color=saturate(diffuse * lit * lightColor+diffuse*ambient);

return color;}


.Squid 23.10.2011 01:45

Ответ: Странное.
 
Обилие условных операторов лучше попытаться заменить на несколько lerp'овъ. Всяко быстрее будет.

Reizel 23.10.2011 02:15

Ответ: Странное.
 
Цитата:

Сообщение от dsd (Сообщение 206653)
Ну деревья я еще в бэйсике понял как генерировать алгоритмом l-system

одно дело понять как алгоритм работает (что самое наилегчайшее:) ), а вот красиво их нагенерить - это уже целое искусство...

dsd 23.10.2011 02:52

Ответ: Странное.
 
Цитата:

Сообщение от Павел (Сообщение 206659)
одно дело понять как алгоритм работает (что самое наилегчайшее:) ), а вот красиво их нагенерить - это уже целое искусство...

Оу. Жесть. Какие-нибудь запускающиеся наработки есть заценить?

Reizel 23.10.2011 13:45

Ответ: Странное.
 
Конечто есть, но в другом городе. Ты дай аську свою, спишемся

dsd 23.10.2011 15:58

Ответ: Странное.
 
Ну ради такого дела завел таки аську: 615638833.
Почему нельзя на форум выложить? Такие тайные технологий что за ними пентагон охотится?

dsd 23.10.2011 17:45

Ответ: Странное.
 

Кажется я сделал велосипед :-D


Придумал генерацию лайтмапов на основе хейгтмапы.

1. Узнаем с какой стороны солнце.
2. Создаем массив из интегер с разрешением в 4 раза больше того массива в котором хранятся данные высот вершин. у меня это (8х32)х(8х32).
3. Узнаем направление источника света в виде 2д вектора. Строим еще один массив с разрешением равным количеству вершин. Далее смещаясь от угла куда первыми приходят лучи от света проверяем затенит ли вершина соседнюю (минимальный перепад высот который будет затенен вычисляется легко, т.к. дельтаикс и дельтаигрек между вершинами постоянны. Заполняем массив значениями. На свету эта вершина или нет.
4. Для мест где соседствуют затененные с освещенными вершины строим более подробные кусочки лайтмапы 4х4.
5. Учусь писать изображение не врайтпикселями, а сразу числами в жопег или бмп.
6. Немного извращений в пиксельном шейдере. И будет быстрая лайтмапа за время исполнения на цпу ~ 1 мс или меньше. :)

Mr_F_ 23.10.2011 18:46

Ответ: Странное.
 
делал нечто подобное, только шейдером, имея карту высот на видюхе и рендеря лайтмап за несколько кадров кусками. шейдер выглдяит вот так:
Код:

        float2 TexCoords = IN.ScreenTC / MapSize;
        float h = tex2D(heighttex,TexCoords).r;
        float height = h * heightMult;
        float3 pos = float3(TexCoords.x,height,TexCoords.y);

        float3 end = saturate(pos - LightDir*(1.0f/MapSize)*128);

        float3 step = (end - pos)/128.0f;


        float p = 0;

        for(int i=0;i<128;i++)
        {
                pos += step;

                p = tex2D(heighttex,pos.xz).r * heightMult;
                if (pos.y < p) return float4(0,1-(step.y*i)/heightMult,0,1);  //0;// Intersection!//
        }

        return 1;// (no intersections)

суть в том что от каждого обрабатываемого пикселя ведётся луч в направлении солнца, и если за требуемое кол-во итераций, луч врезается в хейтмап, значит пиксель затенён.

Reizel 23.10.2011 18:58

Ответ: Странное.
 
Цитата:

Сообщение от dsd (Сообщение 206685)
Почему нельзя на форум выложить? Такие тайные технологий что за ними пентагон охотится?

Можно, даже нужно, и даже выложу, но я смотрю, что у тебя здорово получается делать генератор, потому имею желание общаться не только на форуме)

dsd 24.10.2011 05:13

Не, там такой говнокод что переделывать уже хочется.

Надо делать отдельно генерацию данных как у меня, здесь мне все еще кажется вполне приличной созданная конструкция. А вот часть где происходит позиционирование вершин надо бы вынести в отдельный класс, где объектом будет вершина и несколько методов её перемещения и контроля. Вообще надо заморочится системой квадов. Ввести какой-нить менеджер квадов запоминающий какой индекс соответствует четырем вершинам с двумя треугольниками и в какой поверхности они есть. Т.к. квадов из одной поверхности все-таки не хватит, а сотня поверхностей как у меня делает узким местом видеокарту.

Решил сочинять класс вода. Имея в виду перегрузку операторов и используя наследование и виртуальные функции. Это будет эпичная хрень на девиантных методах программирования :)

Код:

//  вектор в тридэ
class float3 {
    public:
    float x;
    float y;
    float z;
};
//вершина
class vert_data {
    public:
    int index;
    float3 position;
    float3 normal;
    /*
    обновление нормали.
    есть четыре вектора (1,0,val00-val10) (0,1,val00-val01) (-1,0,val00-(val-10)) (0,1,val00-(val0-1))
    попарно векторное умножение даст четыре нормали сумма/4 результирующая нормаль.
    одно вычисление валидно для четырех квадов
    */
};
//квад
class quad {
    public:
    Handle *surf;
    vert_data v00;
    vert_data v01;
    vert_data v10;
    vert_data v11;
    int index;
};

//менеджер квадов
class manager {
    public:
    //массив под поверхности
    Handle *surf;
    // массив квадов
    quad ****sys;
    //размер элемента группы квадов.
    int size;
};

class water {
    public:
    manager sea;
    manager river;
    manager lake;
};

Вот такой мне представляется структура... эмм... комплекса классов для разных типов воды.

Цитата:

Сообщение от impersonalis (Сообщение 206528)
неужели есть люди, которые думают, что изучат ЯП, прочитав учебник? Разумеется, надо развиваться и самостоятельно. Однако, благодаря квази-студентам, которые не в состоянии написать диплом, девальвация образования и поддерживается. У меня много примеров студентов, которые работали (в т.ч. и по специальности) и учились (без кавычек). ЧЯДНТ?
Честно говоря, теперь, узнав что автор уже человек с высшим образованием, технарь, не может осилить относительно простую теорию (в которой сам заинтересован - а такая мотивация сдвигает горы), я испытываю батхёрт мне приходит в голову анекдот (изначально он был с полит.подтекстом, но не нашёл оригинала).
http://www.detskie-anekdoty.ru/detsk...po lgoda.html
dsd, умерьте спесь: если б вы были семи пядей во лбу и действительно ценили своё время - вы бы бросили учёбу курсе на первом-втором. А так - гордится тут абсолютно нечем.
Прошу извинить, если обидел. Это сугубо моё мнение. Практика показала, что, разумеется, есть и другие стратегии поведения, но они сопровождаются и другими решениями (типа того, что я привёл: бывает да - ВУЗ не тот выбрал, со специальностью ошибся, недооценил свой интеллект). Думаю, нам всё же пора вернуться к теме обсуждений, а не доказывать друг другу свою крутость.

Наверно в Москве строителей готовят в технических вузах. Я учился в технологическом. Математика там преподавалась одну пару в неделю первые два курса, с одним практическим занятием раз в две недели. А всякие сопроматы к математике имеют такое же отношение как и хоровое пение. На технических специальностях помоему дают больше математики за один первый месяц, причем в том числе по часам :-). Так что у строителей дело с математикой обстоит может и лучше чем у бухов но едва-едва.

Придумал прикольную защиту от кряканья триальных версий. Делается обычный таймер по которому приложение вырубается.

создается второй таймер, который сработает через время: таймер1+RND(10,240);

Создаем меш, парентим его к камере, создаем поверхность 30-40 тыщ квадов перед камерой, так чтобы они перекрывали обзор, а координаты у вершин образовывающих квад совпадали. Ставим этому мешу xEntityAlpha mesh,0.01. xHideEntity mesh
если таймер2 дотикал до своего времени xShowEntity mesh.
Fatality.
Драйвер видюхи в панике. И даже если после восстановления все ок, это ттттттттрмооооооозззззззззиииииииитттттт адски, а почему не понятно и не видно :)

Какие-то проблемы, ок вышлите нам екзешник, ага значит проблемы нет?

Цитата:

Your use of this software is subject to the terms of the
agreement located at http://go.microsoft.com/fwlink/?link...08&clcid=0x409.

If you do not agree to these terms, you may not use the software.
Это типа можно использовать даже если я не согласен с условиями их лицензии?

moka 24.10.2011 20:53

Ответ: Странное.
 
Использование данного софта Вами, покрывается условиями соглашения, по ссылке: ...

Если вы не согласны с условиями соглашения, вы не должны использовать данный софт.

dsd 25.10.2011 00:27

Ответ: Странное.
 

Маленькое вуду со снегом и чем-то вроде контрастности зависящей от текстуры.

Код:

float4 color=diffuse * lit * lightColor+diffuse*ambient;
color=1.1*pow(color,1.7);
if(input.position2>=75.0f) {color=1.1*pow(color,4);}
return color;}

Можно забацать очень психоделический шейдер если еще и кубамапу как-нибудь не адекватно использовать и блики от отраженного света.

impersonalis 25.10.2011 00:32

Ответ: Странное.
 
выглядит круто

Reizel 25.10.2011 03:16

Ответ: Странное.
 
Дерево

Суть в чем: есть главная рекурсивная функция BuildTree, принимающая параметром небольшую структурку:
Код:

struct Trunc{
        float x,y,z;                //Координаты
        float nx,ny,nz;            //Нормаль епта)
        float fSectionSize;        //Размер одной секции (длина)
        float fSectionRadius;      //Радиус секции, стартовый         
        float fSectionFinishRadius; //КОгда кончать строить хуйту

        int iMesh,iSurface;        //Геометрия, сурфейс
        int iVertexCount;          //Точность
        int iSectionCount;          //Количество секций, блеать
        int iLeafSurface;          //Сурфейс листвы
    };

По нему она строит циклично ствол + искривляет его чуть чуть, и в каждом стыке запускает еще пару-тройку рекурсивных стволов (чуть -чуть изменяя структуру входную)


dsd 25.10.2011 11:00

Ответ: Странное.
 


Код:

Function BuildTree()
gh=xLoadMesh("mesh/tree.b3d")
xEntityTexture gh,treetex
base=xCopyEntity (gh)
xScaleEntity base,2,1,2

MakeItCone(gh)



ph=xCreateCube()
xPositionMesh ph,0,1,0
xEntityAlpha ph,0.1
CreateChilds(ph,1,1)



For d=0 To xCountChildren(ph)-1
        child=xGetChild(ph,d)
        CreateChilds(child,0.6,0.5)
Next


For d=0 To xCountChildren(ph)-1
        child=xGetChild(ph,d)
                For z=0 To xCountChildren(child)-1
                        childl2=xGetChild(child,z)
                        CreateChilds(childl2,0.8,0.25)
                Next
Next

For d=0 To xCountChildren(ph)-1
        child=xGetChild(ph,d)
                For z=0 To xCountChildren(child)-1
                        childl2=xGetChild(child,z)
                                For x=0 To xCountChildren(childl2)-1
                                        childl3=xGetChild(childl2,x)
                                                CreateChilds(childl3,1.2,0.125)
                                Next
                Next
Next
End Function

Function CreateChilds(child,zscale#,level#)
qbranches=Rand(1,4)
sdegree=Rand(0,359)
For i=0 To qbranches

pc=xCopyEntity(gh,child)
xPositionEntity pc,0,xMeshHeight(child)-0.01,0
xScaleEntity pc,level,zscale+Rnd(-0.1,0.1),level
xRotateEntity pc,40+Rnd(-15,15),sdegree+i*(360/(qbranches+1))+Rnd(-25,25),0
Next
End Function

Но это глупо все-таки. По-моему надо замутить покореженный ствол с минимумом толстых корявых веток. На конце каждой ветки сделать типа моих камней только с низкой детализацией, и натыкать рандомно штук 10-20 двухсторонних квадов для имитации отдельных мелких веток. И все одной поверхностью. Ствол можно думать из сетки деформированной шумом перлина и свернутой в цилиндр, которую еще несколькими синусами вдоль игрека изогнуть и в переменно от высоты отскэйлить. То же и для веток. Должно получиться дешево и сердито.

У тебя кстати получилось похоже на алгоритм в котором есть несколько точек куда ветки должны более охотно расти.

Reizel 25.10.2011 14:09

Ответ: Странное.
 
Твое дерево круче смотрится, но оно состоит из готовой модели??
мое делается с нуля, вот код

а насчет рандомного ствола - проще сделать окружность, слегка помятую:


и по ней строить ствол.

dsd 25.10.2011 14:43

Ответ: Странное.
 
Нет. Там 12 полигонов свернутых в трубочку и раставленными в тридэмаксе тектсурными координатами. Раньше для меня было проблемой сгенерировать такой меш. А деревья одинаковые. У твоего со ствлом все гуд, лучше чем у меня, но вот листья приклеены неправильно. Их надо клейть ближе к концам веток, на толстых частях ветвей у нормального дерева листьев нет, если это не тополь. И если ты присмотришься к самим листьям у нормального дерева, то увидешь, что листья у них примерно одного размера и нормали поверхности ВСЕХ листьев смотрят в одном направлении, на источник освещения. Впринципе последний левел ветвей должен быть плоским и стараться лежать в плоскости примерно паралельной плоскости с нормалью (0,1,0) плюс минус 15 градусов. Вот такие у меня дополнеия к эль сустем.

кстати можно не заморачиваться со слиянием всех элементов дерева в одну поверхность я уже практически дописал менеджер квадов, который можно будет легко превратить в менеджер трианглов каковым и обернуть все полигоны сингосюрфицируемого дерева. А потом провести слияние вершин с одинаковыми нормалями позициями и текстурными координатами. Единственно надо пытаться уложиться по полигонам в ~15к .

Reizel 25.10.2011 16:14

Ответ: Странное.
 
Вот с листвой то у меня и были основные проблемы))
Не знал как их клеить. Да и тормозное оно какое-то, из за тексы с альфаканалом ФПС падает в 2 раза. Провал :(

dsd 25.10.2011 16:49

Ответ: Странное.
 
. Ну вот поэтому я и хочу основную часть листвы имитировать несколькими мятыми облачками.
Кстати твоему дереву не от чего тормозить, разве что ты каждый листик сделал отдельным сюрфейсом, тогда да. Мое не тормозило на встроеном intel gma 945. При этом еще и листики все поварачивались к камере на каждый кадр.

у тебя фэйл по элементам образующим твое дерево, а по само алгоритму пока все нормально, наверно. Так пару раз бубном стукнуть и полсотни строк накидать, что бы листья синглсюрфейсом стали.

Reizel 25.10.2011 17:24

Ответ: Странное.
 
Листья синглсюрфейс
Код:

struct Trunc{
        float x,y,z;                //Координаты
        float nx,ny,nz;            //Нормаль епта)
        float fSectionSize;        //Размер одной секции (длина)
        float fSectionRadius;      //Радиус секции, стартовый            :    size
        float fSectionFinishRadius; //КОгда кончать строить хуйту

        int iMesh,iSurface;        //Геометрия, сурфейс
        int iVertexCount;          //Точность
        int iSectionCount;          //Количество секций, блеать
      int iLeafSurface;          //Сурфейс листвы
    };

ПС может я не так понимаю значение термина "синглсюрфейс" ?

dsd 25.10.2011 17:58

Ответ: Странное.
 
Вот то что я понимаю под синглсюрфейс. Пытался сделать легкий доступ к кваду и вроде получилось. Осталось нормальный контроль кол-ва сделать и можно будет кой-чо делать.

PHP код:

//  вектор в тридэ
class float3 {
    public:
    
float x;
    
float y;
    
float z;

    
float3(){
    
x=0.0f;
    
y=0.0f;
    
z=0.0f;
    }

    
void set(float afloat b,float c)
    {
      
x=ay=b;z=c;
    }
};
//вершина
class vert_data {
    public:
    
int index;
    
Handle surf;
    
float3 *position;
    
float3 *normal;

    
vert_data(){
    
position= new float3;
    
normal= new float3;
    }

    
void setnormal(float afloat b,float c){
        
xVertexNormal(surf,index,a,b,c);
        
normal->set(a,b,c);}

    
void setposition(float afloat b,float c){
        
xVertexCoords(surf,index,a,b,c);
        
xVertexTexCoords(surf,index,a,c);
        
position->set(a,b,c);}
    
/*
    обновление нормали.
    есть четыре вектора (1,0,val00-val10) (0,1,val00-val01) (-1,0,val00-(val-10)) (0,1,val00-(val0-1))
    попарно векторное умножение даст четыре нормали сумма/4 результирующая нормаль.
    одно вычисление валидно для четырех квадов
    */
};
//квад
class quad {
    public:
    
Handle surf;
    
vert_data *v00;
    
vert_data *v01;
    
vert_data *v10;
    
vert_data *v11;
    
int index;

    
quad(){
    
v00= new vert_data;
    
v01= new vert_data;
    
v10= new vert_data;
    
v11= new vert_data;
    }
};

//менеджер квадов
class manager {
    public:
    
Handle mesh;
    
//массив под поверхности
    
Handle *surf;
    
// массив квадов
    // сикока квадо увсего
    
int cquad;
    
quad **sys;

    
//размер элемента группы квадов.
    
int size;
    
//methods area
    //constructor
    
manager();


};

manager :: manager(){
        
//ограничение числа индексов в 65536
        //значит число квадов в поверхности
        
int quadnum=256*64;
        
cquad=0;
        
mesh=xCreateMesh();
        
int number=4;
        
surf= new Handle[number];
        
sys = new quad*[quadnum*number];

        for(
int i=0;i<number;i++){
        
surf[i]=xCreateSurface(mesh);


            for(
int j=0;j<quadnum;j++){
            
int v00=xAddVertex(surf[i],0,0,0,0,0);
            
int v01=xAddVertex(surf[i],0,0,0,0,0);
            
int v10=xAddVertex(surf[i],0,0,0,0,0);
            
int v11=xAddVertex(surf[i],0,0,0,0,0);

            
xAddTriangle(surf[i],v00,v01,v10);
            
xAddTriangle(surf[i],v01,v11,v10);
            
//заполнение данными вышележащей(или глубже) структуры
            
sys[cquad]=new quad;
            
sys[cquad]->index=cquad;
            
sys[cquad]->surf=surf[i];
            
sys[cquad]->v00->index=v00;  sys[cquad]->v00->surf=sys[cquad]->surf;  sys[cquad]->v00->setposition(0.0f,0.0f,0.0f);   sys[cquad]->v00->setnormal(0.0f,1.0f,0.0f);
            
sys[cquad]->v10->index=v10;  sys[cquad]->v10->surf=sys[cquad]->surf;  sys[cquad]->v10->setposition(1.0f,0.0f,0.0f);   sys[cquad]->v10->setnormal(0.0f,1.0f,0.0f);
            
sys[cquad]->v01->index=v01;  sys[cquad]->v01->surf=sys[cquad]->surf;  sys[cquad]->v01->setposition(0.0f,0.0f,1.0f);   sys[cquad]->v01->setnormal(0.0f,1.0f,0.0f);
            
sys[cquad]->v11->index=v11;  sys[cquad]->v11->surf=sys[cquad]->surf;  sys[cquad]->v11->setposition(1.0f,0.0f,1.0f);   sys[cquad]->v11->setnormal(0.0f,1.0f,0.0f);

            
cquad++;
              }
        }
    } 

итоговый управляющий код:

PHP код:

manager uno;

     for(
int i=0;i<uno.cquad;i++){
     
uno.sys[i]->v00->setposition(i,i,0);       uno.sys[i]->v00->setnormal(0,1,0);
     
uno.sys[i]->v10->setposition(i+1,i+1,0);   uno.sys[i]->v10->setnormal(0,1,0);
     
uno.sys[i]->v01->setposition(i,i,1);       uno.sys[i]->v01->setnormal(0,1,0);
     
uno.sys[i]->v11->setposition(i+1,i+1,1);   uno.sys[i]->v11->setnormal(0,1,0);
    }
    
xCalculateFrustumVolume(uno.mesh); 

Смысл в том что одной поверхностью можно имитировать наличие нескольких тысяч частиц, тех же спрайтов к примеру. И рисоваться они будут за один дип вместо нескольких тысяч. На примере своего ландшафта я понял, что чем больше треугольников в одном дипе тем лучше. так как, что при 30к треугольников на экране, что при 150к фпс оставался практически идентичным даже на встроенном в сандибридж видео.

dsd 27.10.2011 00:26

Ответ: Странное.
 

провел ацкую для моих способностей кодера битву за дипы. Снизил их количество радикально. Узнал много нового про ссылки и че нельзя и чего не надо делать с классами. Результат двоякий, фпс минимальный не повысился, средний возрос от полутора до двух раз. Теперь можно в любом месте вырезать дырку без регенерации поверхностей. Теперь данные генерируются и хранятся в одном классе, а модели в другом.

Код:

//  вектор в тридэ
class float3 {
    public:
    float x;
    float y;
    float z;

    float3(){
    x=0.0f;
    y=0.0f;
    z=0.0f;
    }

    float3(float a, float b, float c){
    x=a;
    y=b;
    z=c;
    }

    void set(float a, float b,float c)
    {
      x=a;
      y=b;
      z=c;
    }
};

float3 operator*(float3 a, float3 b){
float3 result;
result.x=a.y*b.z-b.y*a.z;
result.y=a.z*b.x-b.z*a.x;
result.z=a.x*b.y-b.x*a.y;
return result;
}

float3 operator*(float3 a, float b){
float3 result(a.x*b,a.y*b,a.z*b);
return result;
}

float3 operator*(float a, float3 b){
float3 result(b.x*a,b.y*a,b.z*a);
return result;
}

float3 operator+(float3 a,float3 b){
float3 result;
result.x=a.x+b.x;
result.y=a.y+b.y;
result.z=a.z+b.z;
return result;
}

float3 operator/(float3 a, float b){
float3 result;
result.x=a.x/b;
result.y=a.y/b;
result.z=a.z/b;
return result;
}
//вершина
class vert_data {
    public:
    int index;
    Handle surf;
    void setnormal(float a, float b,float c){
        xVertexNormal(surf,index,a,b,c);
        }
    void setnormal(float3 a){
        xVertexNormal(surf,index,a.x,a.y,a.z);
        }


    void setposition(float a, float b,float c){
        xVertexCoords(surf,index,a,b,c);
        xVertexTexCoords(surf,index,a,c);
        }
    /*
    обновление нормали.
    есть четыре вектора (1,0,val00-val10) (0,1,val00-val01) (-1,0,val00-(val-10)) (0,1,val00-(val0-1))
    попарно векторное умножение даст четыре нормали сумма/4 результирующая нормаль.
    одно вычисление валидно для четырех квадов
    */
};
//квад
class quadz {
    public:
    Handle surf;
    vert_data v00;
    vert_data v01;
    vert_data v10;
    vert_data v11;
    int index;


};

//менеджер квадов
class manager {
    public:
    Handle mesh;
    //массив под поверхности
    Handle *surf;
    // массив квадов
    // сикока квадо увсего
    quadz **quad;

    //размер элемента группы квадов.
    int size;
    //methods area
    //constructor
    manager(int limiter);
};

manager::manager(int limiter){

        //ограничитель кол-ва квадов
        //ограничение числа индексов в 65536
        //значит число квадов в поверхности
        int quadnum=256*64;
        int cquad=0;
        mesh=xCreateMesh();
        int number=ceil(limiter/quadnum)+1;
        surf= new Handle[number];
        quad = new quadz*[quadnum*number];

        for(int i=0;i<number;i++){
        surf[i]=xCreateSurface(mesh);


            for(int j=0;j<quadnum;j++){
                if(cquad==limiter){break;}
            int v00=xAddVertex(surf[i],0,0,0,0,0);
            int v01=xAddVertex(surf[i],0,0,0,0,0);
            int v10=xAddVertex(surf[i],0,0,0,0,0);
            int v11=xAddVertex(surf[i],0,0,0,0,0);

            xAddTriangle(surf[i],v00,v01,v10);
            xAddTriangle(surf[i],v01,v11,v10);
            //заполнение данными вышележащей(или глубже) структуры
            quad[cquad]=new quadz;
            quad[cquad]->index=cquad;
            quad[cquad]->surf=surf[i];
            quad[cquad]->v00.index=v00;  quad[cquad]->v00.surf=quad[cquad]->surf;
            quad[cquad]->v10.index=v10;  quad[cquad]->v10.surf=quad[cquad]->surf;
            quad[cquad]->v01.index=v01;  quad[cquad]->v01.surf=quad[cquad]->surf;
            quad[cquad]->v11.index=v11;  quad[cquad]->v11.surf=quad[cquad]->surf;

            cquad++;

              }
          if(cquad==limiter){break;}

        }
        size=cquad;
    }



class ground{
public:
//текущая позиция камеры
int x,y;
//***************************************
//далекое
Handle farmesh;
//далекое поверхность
Handle farsur;

// разрешение наиболее детализировнных ячеек.
int resolution;
// разрешение клеток средней детализации
int resol;
int number;
//data for deformations
//хранитель мирового зерна.
int uppersize;
float **seed;
int grain;
//массивы билжнего плана.
float ****strip;
//массивы среднего плана.
float ****stripm;

//шершавость нижнего уровня
float sharpness;
//сглживание
float smothing;
float defkof;
//нижняя точка всего ландшафта
float minimum;
//высота ландшафта
float height;
//скэйл текстур

//******************************************


//конструктор класса
ground(){
    //position intitilazer
    x=xEntityX(Pivot);
    y=xEntityZ(Pivot);
    //Mesh creation

    //surface for mesh
    //создание ближнего квадрата
    number=6;
    resolution=32;
    sharpness=0.25f;
    minimum=1000.4f;
    //ближний план

    //генерация мирового зерна
    int upsize=10;
    uppersize=1<<upsize;
    grain=xMillisecs();
    First_Generator(upsize,xMillisecs());
    //структура данных ближнего плана
    strip= new float ***[number+2];
    for(int i=0;i<number+2;i++){strip[i]=new float **[number+2];}
    //генерация деформационных массивов ближнего квадрата.
    for(int i=0;i<number+2;i++){for(int j=0;j<number+2;j++){
    strip[i][j]=new float *[resolution+1];
    for(int k=0;k<=resolution;k++){strip[i][j][k]=new float[resolution+1];}}}
    for(int i=0;i<number+2;i++){for(int j=0;j<number+2;j++){Diamond_Square(i,j,sharpness, smothing);}}
    //структура данных среднего плана
    resol=resolution/4;
        //средний план

    stripm= new float ***[3*number+2];
    for(int i=0;i<3*number+2;i++){stripm[i]=new float **[3*number+2];}
    //генерация деформационных массивов среднего квадрата.
    for(int i=0;i<3*number+2;i++){for(int j=0;j<3*number+2;j++){
    stripm[i][j]=new float *[resol+1];
    for(int k=0;k<=resol;k++){stripm[i][j][k]=new float[resol+1];}}}
    for(int i=0;i<3*number+2;i++){for(int j=0;j<3*number+2;j++){Diamond_Squarem(i,j,4*sharpness, smothing);}}
    //*******************************************

    farmesh=xCreateMesh();
    //xEntityFX(farmesh,2);
    farsur=xCreateSurface(farmesh);
    int seize=50;
        for(int i=-0.5*seize;i<=0.5*seize;i++){for(int j=-0.5*seize;j<=0.5*seize;j++){
            int v0=xAddVertex(farsur,i*resolution,0,j*resolution,i*resolution,j*resolution);
            int v1=xAddVertex(farsur,(i+1)*resolution,0,j*resolution,(i+1)*resolution,j*resolution);
            int v2=xAddVertex(farsur,i*resolution,0,(j+1)*resolution,i*resolution,(j+1)*resolution);
            int v3=xAddVertex(farsur,(i+1)*resolution,0,(j+1)*resolution,(i+1)*resolution,(j+1)*resolution);
if(((i>=number*1.5 || i<-number*1.5) && (j>=number*1.5 || number*1.5<-1)) || ((i<number*1.5 || i>-number*1.5) && (j>=number*1.5 || j<-number*1.5)) ||((i>=number*1.5 || i<-number*1.5) && (j<number*1.5 || j>-number*1.5))) {xAddTriangle(farsur,v1,v0,v2); xAddTriangle(farsur,v3,v1,v2);}
}}

    Handle seaside_tex=xLoadTexture("tex/Gravel01.jpg");
    Handle lgrass_tex=xLoadTexture("tex/Grass01.jpg");
    Handle dgrass_tex=xLoadTexture("tex/Grass02.jpg");
    Handle plain_tex=xLoadTexture("tex/Gravel02.jpg");
    Handle lmountain_tex=xLoadTexture("tex/dirt01.jpg");
    Handle mmountain_tex=xLoadTexture("tex/rock01.jpg");
    Handle hmountain_tex=xLoadTexture("tex/snow02.jpg");
    Handle smountain_tex=xLoadTexture("tex/snow01.jpg");
    Handle rock_tex=xLoadTexture("tex/rockn.jpg");

    Handle Shader=xLoadFXFile("shader/landpainter.fx");

    xSetEntityEffect(farmesh,Shader);
    xSetEffectTexture(farmesh,"seaside",seaside_tex);
    xSetEffectTexture(farmesh,"lgrass",lgrass_tex);
    xSetEffectTexture(farmesh,"dgrass",dgrass_tex);
    xSetEffectTexture(farmesh,"plain",plain_tex);
    xSetEffectTexture(farmesh,"lmountain",lmountain_tex);
    xSetEffectTexture(farmesh,"mmountain",mmountain_tex);
    xSetEffectTexture(farmesh,"hmountain",hmountain_tex);
    xSetEffectTexture(farmesh,"smountain",smountain_tex);
    xSetEffectTexture(farmesh,"rockn",rock_tex);
    xSetEffectTechnique(farmesh, "Diffuse");
    xSetEffectFloat(farmesh,"scale",0.3);
}
//***************************************************
//***************************************************
void Update_Environment(){
    srand(x+y);
xPositionEntity(farmesh,x,0,y);
int qvert=xCountVertices(farsur);
for(int i=0;i<qvert;i++){
//смотрим в мировое зерно
int u=xVertexX(farsur,i);
int v=xVertexZ(farsur,i);
//адрес текущей точки в массиве значений
int xj=xMod((x+u)/resolution+4,uppersize);
int yj=xMod((y+v)/resolution+4,uppersize);
float val=seed[xj][yj];
xVertexCoords(farsur,i,u,val,v);

    float m[3][4];
    //вычисляю индекс вершины

    //первая нормаль
    int x1=-1; int z1=0;
    int x2=0; int z2=1;
    float y0=seed[xMod(xj,uppersize)][xMod(yj,uppersize)];
    float y1=seed[xMod(xj+x1,uppersize)][xMod(yj+z1,uppersize)];
    float y2=seed[xMod(xj+x2,uppersize)][xMod(yj+z2,uppersize)];
    m[0][0]=y1-y0;
    m[1][0]=-1;
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    y1=seed[xMod(xj+x1,uppersize)][xMod(yj+z1,uppersize)];
    y2=seed[xMod(xj+x2,uppersize)][xMod(yj+z2,uppersize)];
    m[0][1]=y0-y2;
    m[1][1]=-1;
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    y1=seed[xMod(xj+x1,uppersize)][xMod(yj+z1,uppersize)];
    y2=seed[xMod(xj+x2,uppersize)][xMod(yj+z2,uppersize)];
    m[0][2]=y0-y1;
    m[1][2]=-1;
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    y1=seed[xMod(xj+x1,uppersize)][xMod(yj+z1,uppersize)];
    y2=seed[xMod(xj+x2,uppersize)][xMod(yj+z2,uppersize)];
    m[0][3]=y2-y0;
    m[1][3]=-1;
    m[2][3]=y1-y0;
    m[0][0]=0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-4.0f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    xVertexNormal(farsur,i,m[0][0],m[1][0],m[2][0]);
}

xCalculateFrustumVolume(farmesh);
}
//***************************************************
void Data_Switcher(int flag){

float **temp[number+2];
//do not touch this, never ever.
    if(flag==0){
        for(int i=0;i<number+2;i++){
            temp[i]=strip[0][i];
                for(int k=0;k<number+1;k++) {strip[k][i]=strip[k+1][i];}
                strip[number+1][i]=temp[i];
                Diamond_Square(number+1,i,sharpness,smothing);}}
    if(flag==1){
        for(int i=0;i<number+2;i++){
            temp[i]=strip[number+1][i];
                for(int k=number+1;k>0;k--) {strip[k][i]=strip[k-1][i];}
                strip[0][i]=temp[i];
                Diamond_Square2(0,i,sharpness,smothing);}}
    if(flag==2){
        for(int i=0;i<number+2;i++){
            temp[i]=strip[i][0];
                for(int k=0;k<number+1;k++) {strip[i][k]=strip[i][k+1];}
                strip[i][number+1]=temp[i];
                Diamond_Square(i,number+1,sharpness,smothing);}}
    if(flag==3){
        for(int i=0;i<number+2;i++){
            temp[i]=strip[i][number+1];
                for(int k=number+1;k>0;k--) {strip[i][k]=strip[i][k-1];}
                strip[i][0]=temp[i];
                Diamond_Square3(i,0,sharpness,smothing);}}

}
//*******************************************
void Data_Switcherm(int flag){

float **temp[3*number+2];
//do not touch this, never ever.
    if(flag==0){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[0][i];
                for(int k=0;k<3*number+1;k++) {stripm[k][i]=stripm[k+1][i];}
                stripm[3*number+1][i]=temp[i];
                Diamond_Squarem(3*number+1,i,4*sharpness,smothing);}}
    if(flag==1){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[3*number+1][i];
                for(int k=3*number+1;k>0;k--) {stripm[k][i]=stripm[k-1][i];}
                stripm[0][i]=temp[i];
                Diamond_Square2m(0,i,4*sharpness,smothing);}}
    if(flag==2){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[i][0];
                for(int k=0;k<3*number+1;k++) {stripm[i][k]=stripm[i][k+1];}
                stripm[i][3*number+1]=temp[i];
                Diamond_Squarem(i,3*number+1,4*sharpness,smothing);}}
    if(flag==3){
        for(int i=0;i<3*number+2;i++){
            temp[i]=stripm[i][3*number+1];
                for(int k=3*number+1;k>0;k--) {stripm[i][k]=stripm[i][k-1];}
                stripm[i][0]=temp[i];
                Diamond_Square3m(i,0,4*sharpness,smothing);}}

}

//сокращение нижнего уровня
void regenerator(int a,int b, float sharp, int size, float ****m, int dis){
//заполнение краев
if(m[a][b][0][0]==0){ m[a][b][0][0]=seed[xMod(x/resolution+a-dis,uppersize)][xMod(y/resolution+b-dis,uppersize)];}
if(m[a][b][size][0]==0) {m[a][b][size][0]=seed[xMod(x/resolution+a+1-dis,uppersize)][xMod(y/resolution+b-dis,uppersize)];}
if(m[a][b][0][size]==0) {m[a][b][0][size]=seed[xMod(x/resolution+a-dis,uppersize)][xMod(y/resolution+b+1-dis,uppersize)];}
if(m[a][b][size][size]==0) {m[a][b][size][size]=seed[xMod(x/resolution+a+1-dis,uppersize)][xMod(y/resolution+b+1-dis,uppersize)];}

int step=size>>1;
while(step>0){for(int i=step;i<=size-step;i=i+2*step){for(int j=step;j<=size-step;j=j+2*step){
        float val00=m[a][b][i-step][j-step];
        float val01=m[a][b][i-step][j+step];
        float val10=m[a][b][i+step][j-step];
        float val11=m[a][b][i+step][j+step];
        if(m[a][b][i][j]==0){m[a][b][i][j]=0.25f*(val00+val01+val10+val11)+step*xRnd(-sharp,sharp);}
        if(m[a][b][i-step][j]==0){m[a][b][i-step][j]=0.5f*(val00+val01+step*xRnd(-sharp,sharp));}
        if(m[a][b][i+step][j]==0){m[a][b][i+step][j]=0.5f*(val10+val11+step*xRnd(-sharp,sharp));}
        if(m[a][b][i][j-step]==0){m[a][b][i][j-step]=0.5f*(val00+val10+step*xRnd(-sharp,sharp));}
        if(m[a][b][i][j+step]==0){m[a][b][i][j+step]=0.5f*(val01+val11+step*xRnd(-sharp,sharp));}}}
step=step>>1;}
}
//*******************************************************
void Diamond_Square(int a,int b, float sharp, int diff){
int size=resolution;
for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){strip[a][b][i][j]=0;}}
srand(seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)]);
for(int i=0;i<=size;i++){
        if(a>0){strip[a][b][0][i]=strip[a-1][b][size][i];}
        if(b>0){strip[a][b][i][0]=strip[a][b-1][i][size];}}
regenerator(a,b,sharp,size,strip,0);}
//********************************************************
void Diamond_Square2(int a,int b, float sharp, int diff){
int size=resolution;
for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){strip[a][b][i][j]=0;}}
srand(seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)]);
for(int i=0;i<=size;i++){
        if(a<number){strip[a][b][size][i]=strip[a+1][b][0][i];}
        if(b>0){strip[a][b][i][0]=strip[a][b-1][i][size];}}
regenerator(a,b,sharp,size,strip,0);}
//********************************************************
void Diamond_Square3(int a,int b, float sharp, int diff){
int size=resolution;
for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){strip[a][b][i][j]=0;}}
srand(seed[xMod(x/resolution+a,uppersize)][xMod(y/resolution+b,uppersize)]);
for(int i=0;i<=size;i++){
        if(a>0){strip[a][b][0][i]=strip[a-1][b][size][i];}
        if(b<number){strip[a][b][i][size]=strip[a][b+1][i][0];}}
regenerator(a,b,sharp,size,strip,0);}
//*******************************************************
void Diamond_Squarem(int a,int b, float sharp, int diff){
int size=resol;
for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){stripm[a][b][i][j]=0;}}
srand(seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b-number,uppersize)]);
for(int i=0;i<=size;i++){
        if(a>0){stripm[a][b][0][i]=stripm[a-1][b][size][i];}
        if(b>0){stripm[a][b][i][0]=stripm[a][b-1][i][size];}}
regenerator(a,b,sharp,size,stripm,number);}
//********************************************************
void Diamond_Square2m(int a,int b, float sharp, int diff){
int size=resol;
for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){stripm[a][b][i][j]=0;}}
srand(seed[xMod(x/resolution+a-number,uppersize)][xMod(y/resolution+b-number,uppersize)]);
for(int i=0;i<=size;i++){
        if(a<number){stripm[a][b][size][i]=stripm[a+1][b][0][i];}
        if(b>0){stripm[a][b][i][0]=stripm[a][b-1][i][size];}}
regenerator(a,b,sharp,size,stripm,number);}
//********************************************************
void Diamond_Square3m(int a,int b, float sharp, int diff){
int size=resol;
for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){stripm[a][b][i][j]=0;}}
srand(seed[xMod(x/resol+a-number,uppersize)][xMod(y/resol+b-number,uppersize)]);
for(int i=0;i<=size;i++){
        if(a>0){stripm[a][b][0][i]=stripm[a-1][b][size][i];}
        if(b<number){stripm[a][b][i][size]=stripm[a][b+1][i][0];}}
regenerator(a,b,sharp,size,stripm,number);}
//********************************************************
float xRnd(float min, float max){
    float length=max-min;
    float var =((float) rand() / (float)RAND_MAX);
    float value=min+var*length;
return value;}
//********************************************************
void First_Generator(int size, int grain){
float max=-10000.01;
srand(grain);
int resolution=1<<size;
//создание структуры данных
float **m1[size];
for(int i=0;i<size;i++){
m1[i]=new float*[resolution];
for(int j=0;j<resolution;j++){m1[i][j]=new float[resolution];}}
//обнуление
for(int i=0;i<size;i++){for(int j=0;j<resolution;j++){for(int k=0;k<resolution;k++){m1[i][j][k]=0;}}}
//создание исходного шума
float length=0;
for(int i=0;i<size;i++){
    int width=1<<(i+1);
        //kof  коэффициент веса октавы
        float detsize=2.0f;
        float kof=(size-i);
        if(i==0){kof=detsize*16;}
        if(i==1){kof=detsize*32;}
        if(i==2){kof=detsize*64;}
        if(i==3){kof=detsize*32;}
        if(i==4){kof=detsize*16;}
        if(i==5){kof=detsize*8;}
        if(i>5){kof=detsize*4;}
        for(int j=0;j<width;j++){for(int k=0;k<width;k++){m1[i][j<<(size-i-1)][k<<(size-i-1)]=kof*(1-2*(float)rand()/RAND_MAX);}}
        //cуммируется вес октав это будет максимально возможный перепад высот
        length=length+kof;}
//что бы коегде заменить все деления умножением
    float len=(0.5/length);
//тут градиентный шум считается
for(int k=0;k<size-1;k++){
int step=resolution>>1;
while(step>0){
    for(int i=step;i<resolution-step;i=i+2*step){
        for(int j=step;j<resolution-step;j=j+2*step){
        //данные в углах текущей клетки
        float val00=m1[k][i-step][j-step];
        float val01=m1[k][i-step][j+step];
        float val10=m1[k][i+step][j-step];
        float val11=m1[k][i+step][j+step];
        //если текущая клетка пуста, то пишется в клетку крест значений
        if(m1[k][i][j]==0){
        m1[k][i][j]=0.25*(val00+val01+val10+val11);
        m1[k][i-step][j]=0.5*(val00+val01);
        m1[k][i+step][j]=0.5*(val10+val11);
        m1[k][i][j-step]=0.5*(val00+val10);
        m1[k][i][j+step]=0.5*(val01+val11);}
    }}
step=step>>1;}}

//суммирование в последний массив
for(int i=0;i<resolution;i++){for(int j=0;j<resolution;j++){for(int k=0;k<size-1;k++){m1[size-1][i][j]=m1[size-1][i][j]+m1[k][i][j];}}}

seed=new float*[resolution];
for(int j=0;j<resolution;j++){seed[j]=new float[resolution];}

//суммирование в последний массив
for(int i=0;i<resolution;i++){
    for(int j=0;j<resolution;j++){
        seed[i][j]=m1[size-1][i][j];
        }}

}
//********************************************************
int xMod(int a,int b){
int c=a-b*floor(a/b);
if(c<0) {c=c+b;}
return c;
}
//********************************************************
};



class land {
    public:
    int resolution;
    int resol;
    int number;

    //ссылка на первичный класс земли
    ground first;
    //это координаты мира для которых система квадов прикинута миром.
    int x,y;
    //манагер квадов
    manager *surf;
    manager *surfm;
    //структура для квадов
    int ****strip;
    int ****stripm;



    land();

void updateland(){

    int xc=xEntityX(Pivot);
    int yc=xEntityZ(Pivot);
    if(xc-resolution-1>x){
        x=x+resolution;
        first.x=x;
        first.Data_Switcher(0);
        first.Data_Switcherm(0);
        first.Update_Environment();
        Data_Switcher(0);
        Data_Switcherm(0);}

    if(xc+resolution+1<x){
        x=x-resolution;
        first.x=x;
        first.Data_Switcher(1);
        first.Data_Switcherm(1);
        first.Update_Environment();
        Data_Switcher(1);
        Data_Switcherm(1);}

    if(yc-resolution-1>y){
        y=y+resolution;
        first.y=y;
        first.Data_Switcher(2);
        first.Data_Switcherm(2);
        first.Update_Environment();
        Data_Switcher(2);
        Data_Switcherm(2);}

    if(yc+resolution+1<y){
        y=y-resolution;
        first.y=y;
        first.Data_Switcher(3);
        first.Data_Switcherm(3);
        first.Update_Environment();
        Data_Switcher(3);
        Data_Switcherm(3);}

    }

void Data_Switcher(int flag){
int **temp[number];
//do not touch this, never ever.
    if(flag==0){
        for(int i=0;i<number;i++){
            temp[i]=strip[0][i];
                for(int k=0;k<number-1;k++) {strip[k][i]=strip[k+1][i];}
                strip[number-1][i]=temp[i];}
                for(int i=0;i<number;i++){migrate_quads(number-1,i);}}

    if(flag==1){
        for(int i=0;i<number;i++){
            temp[i]=strip[number-1][i];
                for(int k=number-1;k>0;k--) {strip[k][i]=strip[k-1][i];}
                strip[0][i]=temp[i];}
                for(int i=0;i<number;i++){migrate_quads(0,i);}}
    if(flag==2){
        for(int i=0;i<number;i++){
            temp[i]=strip[i][0];
                for(int k=0;k<number-1;k++) {strip[i][k]=strip[i][k+1];}
                strip[i][number-1]=temp[i];}
                for(int i=0;i<number;i++){migrate_quads(i,number-1);}}
    if(flag==3){
        for(int i=0;i<number;i++){
            temp[i]=strip[i][number-1];
                for(int k=number-1;k>0;k--) {strip[i][k]=strip[i][k-1];}
                strip[i][0]=temp[i];}
                for(int i=0;i<number;i++){migrate_quads(i,0);}}
    xCalculateFrustumVolume(surf->mesh);
}

void Data_Switcherm(int flag){
int **temp[3*number];
//do not touch this, never ever.
    collapse_quadsm();
    if(flag==0){
        for(int i=0;i<3*number;i++){
            temp[i]=stripm[0][i];
                for(int k=0;k<3*number-1;k++) {stripm[k][i]=stripm[k+1][i];}
                stripm[3*number-1][i]=temp[i];}
                for(int i=0;i<3*number;i++){migrate_quadsm(3*number-1,i);}
                for(int i=number;i<2*number;i++){migrate_quadsm(number-1,i);}}

    if(flag==1){
        for(int i=0;i<3*number;i++){
            temp[i]=stripm[3*number-1][i];
                for(int k=3*number-1;k>0;k--) {stripm[k][i]=stripm[k-1][i];}
                stripm[0][i]=temp[i];}
                for(int i=0;i<3*number;i++){migrate_quadsm(0,i);}
                for(int i=number;i<2*number;i++){migrate_quadsm(2*number,i);}}
    if(flag==2){
        for(int i=0;i<3*number;i++){
            temp[i]=stripm[i][0];
                for(int k=0;k<3*number-1;k++) {stripm[i][k]=stripm[i][k+1];}
                stripm[i][3*number-1]=temp[i];}
                for(int i=0;i<3*number;i++){migrate_quadsm(i,3*number-1);}
                for(int i=number;i<2*number;i++){migrate_quadsm(i,number-1);}}
    if(flag==3){
        for(int i=0;i<3*number;i++){
            temp[i]=stripm[i][3*number-1];
                for(int k=3*number-1;k>0;k--) {stripm[i][k]=stripm[i][k-1];}
                stripm[i][0]=temp[i];}
                for(int i=0;i<3*number;i++){migrate_quadsm(i,0);}
                for(int i=number;i<2*number;i++){migrate_quadsm(i,2*number);}}

    xCalculateFrustumVolume(surfm->mesh);
}



void collapse_quadsm(){
    for(int a=number;a<2*number;a++){
        for(int b=number;b<2*number;b++) {
            for(int i=0;i<resol;i++){
                for(int j=0;j<resol;j++){
            int index=stripm[a][b][i][j];
            int cont=-100;
            surfm->quad[index]->v00.setposition(x+(a-1.5*number)*resolution+i*4,first.stripm[a+1][b+1][i][j]+cont,y+(b-1.5*number)*resolution+j*4);
            surfm->quad[index]->v10.setposition(x+(a-1.5*number)*resolution+i*4+4,first.stripm[a+1][b+1][i+1][j]+cont,y+(b-1.5*number)*resolution+j*4);
            surfm->quad[index]->v01.setposition(x+(a-1.5*number)*resolution+i*4,first.stripm[a+1][b+1][i][j+1]+cont,y+(b-1.5*number)*resolution+j*4+1*4);
            surfm->quad[index]->v11.setposition(x+(a-1.5*number)*resolution+i*4+4,first.stripm[a+1][b+1][i+1][j+1]+cont,y+(b-1.5*number)*resolution+j*4+1*4);
                }}}}

}


void migrate_quadsm(int a,int b){
    for(int i=0;i<resol;i++){
        for(int j=0;j<resol;j++){
            int index=stripm[a][b][i][j];
            surfm->quad[index]->v00.setposition(x+(a-1.5*number)*resolution+i*4,first.stripm[a+1][b+1][i][j],y+(b-1.5*number)*resolution+j*4);
            surfm->quad[index]->v10.setposition(x+(a-1.5*number)*resolution+i*4+4,first.stripm[a+1][b+1][i+1][j],y+(b-1.5*number)*resolution+j*4);
            surfm->quad[index]->v01.setposition(x+(a-1.5*number)*resolution+i*4,first.stripm[a+1][b+1][i][j+1],y+(b-1.5*number)*resolution+j*4+1*4);
            surfm->quad[index]->v11.setposition(x+(a-1.5*number)*resolution+i*4+4,first.stripm[a+1][b+1][i+1][j+1],y+(b-1.5*number)*resolution+j*4+1*4);

            //расчет нормалей
            //нормаль для точки v00
            //получение значений
    float m[3][4];

    //первая нормаль
    int x1=-1; int z1=0;
    int x2=0; int z2=1;
    float y0=first.stripm[a+1][b+1][i][j];
    float y1;
    if(i==0){y1=first.stripm[a][b+1][i+x1+resol][j+z1];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    float y2;
    if(j==resol){y2=first.stripm[a+1][b+2][i+x2][j+z2-resol];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][0]=y1-y0;
    m[1][0]=-1;
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resol){y1=first.stripm[a+1][b+2][i+x1][j+z1-resol];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(i==resol){y2=first.stripm[a+2][b+1][i+x2-resol][j+z2];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][1]=y0-y2;
    m[1][1]=-1;
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resol) {y1=first.stripm[a+2][b+1][i+x1-resol][j+z1];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=first.stripm[a+1][b][i+x2][j+z2+resol];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][2]=y0-y1;
    m[1][2]=-1;
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=first.stripm[a+1][b][i+x1][j+z1+resol];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=first.stripm[a][b+1][i+x2+resol][j+z2];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][3]=y2-y0;
    m[1][3]=-1;
    m[2][3]=y1-y0;


    m[0][0]=0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.8f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    surfm->quad[index]->v00.setnormal(m[0][0],m[1][0],m[2][0]);

    i++;
            //нормаль для точки v10
            //получение значений

    m[3][4];
    //первая нормаль
    x1=-1; z1=0;
    x2=0; z2=1;
    y0=first.stripm[a+1][b+1][i][j];
    y1;
    if(i==0){y1=first.stripm[a][b+1][i+x1+resol][j+z1];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    y2;
    if(j==resol){y2=first.stripm[a+1][b+2][i+x2][j+z2-resol];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][0]=y1-y0;
    m[1][0]=-1;
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resol){y1=first.stripm[a+1][b+2][i+x1][j+z1-resol];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(i==resol){y2=first.stripm[a+2][b+1][i+x2-resol][j+z2];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][1]=y0-y2;
    m[1][1]=-1;
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resol) {y1=first.stripm[a+2][b+1][i+x1-resol][j+z1];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=first.stripm[a+1][b][i+x2][j+z2+resol];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][2]=y0-y1;
    m[1][2]=-1;
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=first.stripm[a+1][b][i+x1][j+z1+resol];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=first.stripm[a][b+1][i+x2+resol][j+z2];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][3]=y2-y0;
    m[1][3]=-1;
    m[2][3]=y1-y0;


    m[0][0]=0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.8f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    surfm->quad[index]->v10.setnormal(m[0][0],m[1][0],m[2][0]);

j++;
            //нормаль для точки v11
            //получение значений

    m[3][4];
    //первая нормаль
    x1=-1; z1=0;
    x2=0; z2=1;
    y0=first.stripm[a+1][b+1][i][j];
    y1;
    if(i==0){y1=first.stripm[a][b+1][i+x1+resol][j+z1];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    y2;
    if(j==resol){y2=first.stripm[a+1][b+2][i+x2][j+z2-resol];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][0]=y1-y0;
    m[1][0]=-1;
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resol){y1=first.stripm[a+1][b+2][i+x1][j+z1-resol];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(i==resol){y2=first.stripm[a+2][b+1][i+x2-resol][j+z2];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][1]=y0-y2;
    m[1][1]=-1;
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resol) {y1=first.stripm[a+2][b+1][i+x1-resol][j+z1];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=first.stripm[a+1][b][i+x2][j+z2+resol];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][2]=y0-y1;
    m[1][2]=-1;
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=first.stripm[a+1][b][i+x1][j+z1+resol];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=first.stripm[a][b+1][i+x2+resol][j+z2];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][3]=y2-y0;
    m[1][3]=-1;
    m[2][3]=y1-y0;


    m[0][0]=0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.8f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    surfm->quad[index]->v11.setnormal(m[0][0],m[1][0],m[2][0]);

i--;
            //нормаль для точки v01
            //получение значений

    m[3][4];
    //первая нормаль
    x1=-1; z1=0;
    x2=0; z2=1;
    y0=first.stripm[a+1][b+1][i][j];
    y1;
    if(i==0){y1=first.stripm[a][b+1][i+x1+resol][j+z1];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    y2;
    if(j==resol){y2=first.stripm[a+1][b+2][i+x2][j+z2-resol];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][0]=y1-y0;
    m[1][0]=-1;
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resol){y1=first.stripm[a+1][b+2][i+x1][j+z1-resol];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(i==resol){y2=first.stripm[a+2][b+1][i+x2-resol][j+z2];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    //x's
    m[0][1]=y0-y2;
    m[1][1]=-1;
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resol) {y1=first.stripm[a+2][b+1][i+x1-resol][j+z1];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=first.stripm[a+1][b][i+x2][j+z2+resol];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][2]=y0-y1;
    m[1][2]=-1;
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=first.stripm[a+1][b][i+x1][j+z1+resol];} else{y1=first.stripm[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=first.stripm[a][b+1][i+x2+resol][j+z2];} else{y2=first.stripm[a+1][b+1][i+x2][j+z2];}
    m[0][3]=y2-y0;
    m[1][3]=-1;
    m[2][3]=y1-y0;


    m[0][0]=0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.8f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    surfm->quad[index]->v01.setnormal(m[0][0],m[1][0],m[2][0]);
    j--;



            }}

}


void migrate_quads(int a,int b){
    for(int i=0;i<resolution;i++){
        for(int j=0;j<resolution;j++){
            int index=strip[a][b][i][j];
            surf->quad[index]->v00.setposition(x+(a-number/2)*resolution+i,first.strip[a+1][b+1][i][j],y+(b-number/2)*resolution+j);
            surf->quad[index]->v10.setposition(x+(a-number/2)*resolution+i+1,first.strip[a+1][b+1][i+1][j],y+(b-number/2)*resolution+j);
            surf->quad[index]->v01.setposition(x+(a-number/2)*resolution+i,first.strip[a+1][b+1][i][j+1],y+(b-number/2)*resolution+j+1);
            surf->quad[index]->v11.setposition(x+(a-number/2)*resolution+i+1,first.strip[a+1][b+1][i+1][j+1],y+(b-number/2)*resolution+j+1);

            //расчет нормалей
            //нормаль для точки v00
            //получение значений

    float m[3][4];
    int x1=-1; int z1=0;
    int x2=0; int z2=1;
    float y0=first.strip[a+1][b+1][i][j];
    float y1;
    if(i==0){y1=first.strip[a][b+1][i+x1+resolution][j+z1];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    float y2;
    if(j==resolution){y2=first.strip[a+1][b+2][i+x2][j+z2-resolution];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][0]=y1-y0;
    m[1][0]=-1;
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resolution){y1=first.strip[a+1][b+2][i+x1][j+z1-resolution];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(i==resolution){y2=first.strip[a+2][b+1][i+x2-resolution][j+z2];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][1]=y0-y2;
    m[1][1]=-1;
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resolution) {y1=first.strip[a+2][b+1][i+x1-resolution][j+z1];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=first.strip[a+1][b][i+x2][j+z2+resolution];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][2]=y0-y1;
    m[1][2]=-1;
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=first.strip[a+1][b][i+x1][j+z1+resolution];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=first.strip[a][b+1][i+x2+resolution][j+z2];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][3]=y2-y0;
    m[1][3]=-1;
    m[2][3]=y1-y0;
    m[0][0]=0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.25f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    surf->quad[index]->v00.setnormal(m[0][0],m[1][0],m[2][0]);

            //нормаль для точки v01
            //получение значений
    j++;
    m[3][4];
    x1=-1;  z1=0;
    x2=0;  z2=1;
    y0=first.strip[a+1][b+1][i][j];
    y1;
    if(i==0){y1=first.strip[a][b+1][i+x1+resolution][j+z1];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    y2;
    if(j==resolution){y2=first.strip[a+1][b+2][i+x2][j+z2-resolution];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][0]=y1-y0;
    m[1][0]=-1;
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resolution){y1=first.strip[a+1][b+2][i+x1][j+z1-resolution];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(i==resolution){y2=first.strip[a+2][b+1][i+x2-resolution][j+z2];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][1]=y0-y2;
    m[1][1]=-1;
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resolution) {y1=first.strip[a+2][b+1][i+x1-resolution][j+z1];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=first.strip[a+1][b][i+x2][j+z2+resolution];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][2]=y0-y1;
    m[1][2]=-1;
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=first.strip[a+1][b][i+x1][j+z1+resolution];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=first.strip[a][b+1][i+x2+resolution][j+z2];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][3]=y2-y0;
    m[1][3]=-1;
    m[2][3]=y1-y0;
    m[0][0]=0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.25f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    surf->quad[index]->v01.setnormal(m[0][0],m[1][0],m[2][0]);

    i++;

        //нормаль для точки v11
            //получение значений
    m[3][4];
    x1=-1;  z1=0;
    x2=0;  z2=1;
    y0=first.strip[a+1][b+1][i][j];
    y1;
    if(i==0){y1=first.strip[a][b+1][i+x1+resolution][j+z1];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    y2;
    if(j==resolution){y2=first.strip[a+1][b+2][i+x2][j+z2-resolution];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][0]=y1-y0;
    m[1][0]=-1;
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resolution){y1=first.strip[a+1][b+2][i+x1][j+z1-resolution];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(i==resolution){y2=first.strip[a+2][b+1][i+x2-resolution][j+z2];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][1]=y0-y2;
    m[1][1]=-1;
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resolution) {y1=first.strip[a+2][b+1][i+x1-resolution][j+z1];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=first.strip[a+1][b][i+x2][j+z2+resolution];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][2]=y0-y1;
    m[1][2]=-1;
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=first.strip[a+1][b][i+x1][j+z1+resolution];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=first.strip[a][b+1][i+x2+resolution][j+z2];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][3]=y2-y0;
    m[1][3]=-1;
    m[2][3]=y1-y0;
    m[0][0]=0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.25f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    surf->quad[index]->v11.setnormal(m[0][0],m[1][0],m[2][0]);
    j--;
        //нормаль для точки v10
            //получение значений

    m[3][4];
    x1=-1;  z1=0;
    x2=0;  z2=1;
    y0=first.strip[a+1][b+1][i][j];
    y1;
    if(i==0){y1=first.strip[a][b+1][i+x1+resolution][j+z1];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    y2;
    if(j==resolution){y2=first.strip[a+1][b+2][i+x2][j+z2-resolution];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][0]=y1-y0;
    m[1][0]=-1;
    m[2][0]=y0-y2;

    //вторая нормаль
    x1=0; z1=1;
    x2=1; z2=0;
    if(j==resolution){y1=first.strip[a+1][b+2][i+x1][j+z1-resolution];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(i==resolution){y2=first.strip[a+2][b+1][i+x2-resolution][j+z2];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][1]=y0-y2;
    m[1][1]=-1;
    m[2][1]=y0-y1;

    //третья нормаль
    x1=1; z1=0;
    x2=0; z2=-1;
    if(i==resolution) {y1=first.strip[a+2][b+1][i+x1-resolution][j+z1];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(j==0) {y2=first.strip[a+1][b][i+x2][j+z2+resolution];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][2]=y0-y1;
    m[1][2]=-1;
    m[2][2]=y2-y0;

    //четвертая нормаль
    x1=0; z1=-1;
    x2=-1; z2=0;
    if(j==0){y1=first.strip[a+1][b][i+x1][j+z1+resolution];} else{y1=first.strip[a+1][b+1][i+x1][j+z1];}
    if(i==0){y2=first.strip[a][b+1][i+x2+resolution][j+z2];} else{y2=first.strip[a+1][b+1][i+x2][j+z2];}
    m[0][3]=y2-y0;
    m[1][3]=-1;
    m[2][3]=y1-y0;
    m[0][0]=0.25f*(m[0][0]+m[0][1]+m[0][2]+m[0][3]);
    m[1][0]=-0.25f*(m[1][0]+m[1][1]+m[1][2]+m[1][3]);
    m[2][0]=0.25f*(m[2][0]+m[2][1]+m[2][2]+m[2][3]);

    surf->quad[index]->v10.setnormal(m[0][0],m[1][0],m[2][0]);

    i--;

            }}

}


};

land::land() {

        //узнаю из переданного объекта разрешение
        resolution=first.resolution;
        number=first.number;
        int quantity=resolution*resolution*number*number;
        //создан объект который прикинется землей ближнего круга.
        surf= new manager(quantity);
        //теперь делю квады на нужное кол-во групп и пишу их индексы в массив
    strip= new int ***[number];
    for(int i=0;i<number;i++){strip[i]=new int **[number];}
    //генерация деформационных массивов ближнего квадрата.
    for(int i=0;i<number;i++){for(int j=0;j<number;j++){
    strip[i][j]=new int *[resolution];
    for(int k=0;k<resolution;k++){strip[i][j][k]=new int[resolution];}}}
    x=0;
    y=0;
    //пишу индексы в размеченный массив.
    int index=0;
    for(int a=0;a<number;a++){
        for(int b=0;b<number;b++) {
            for(int i=0;i<resolution;i++){
                for(int j=0;j<resolution;j++){
                    strip[a][b][i][j]=index;
                    surf->quad[index]->v00.setposition((a-number/2)*resolution+i,first.strip[a+1][b+1][i][j],(b-number/2)*resolution+j);
                    surf->quad[index]->v10.setposition((a-number/2)*resolution+i+1,first.strip[a+1][b+1][i+1][j],(b-number/2)*resolution+j);
                    surf->quad[index]->v01.setposition((a-number/2)*resolution+i,first.strip[a+1][b+1][i][j+1],(b-number/2)*resolution+j+1);
                    surf->quad[index]->v11.setposition((a-number/2)*resolution+i+1,first.strip[a+1][b+1][i+1][j+1],(b-number/2)*resolution+j+1);
                    index++;}}}}
    for(int a=0;a<number;a++){
        for(int b=0;b<number;b++) {migrate_quads(a,b);}}


    resol=first.resol;

        quantity=resol*resol*number*number*3*3;
        //создан объект который прикинется землей ближнего круга.
        surfm= new manager(quantity);

    stripm= new int ***[3*number];
    for(int i=0;i<3*number;i++){stripm[i]=new int **[3*number];}
    //генерация деформационных массивов среднего квадрата.
    for(int i=0;i<3*number;i++){for(int j=0;j<3*number;j++){
    stripm[i][j]=new int *[resol];
    for(int k=0;k<resol;k++){stripm[i][j][k]=new int[resol];}}}
    index=0;
    for(int a=0;a<3*number;a++){
        for(int b=0;b<3*number;b++) {
            for(int i=0;i<resol;i++){
                for(int j=0;j<resol;j++){
                    stripm[a][b][i][j]=index;
                    surfm->quad[index]->v00.setposition((a-1.5*number)*resolution+i*4,first.stripm[a+1][b+1][i][j],(b-1.5*number)*resolution+j*4);
                    surfm->quad[index]->v10.setposition((a-1.5*number)*resolution+(i+1)*4,first.stripm[a+1][b+1][i+1][j],(b-1.5*number)*resolution+j*4);
                    surfm->quad[index]->v01.setposition((a-1.5*number)*resolution+i*4,first.stripm[a+1][b+1][i][j+1],(b-1.5*number)*resolution+(j+1)*4);
                    surfm->quad[index]->v11.setposition((a-1.5*number)*resolution+(i+1)*4,first.stripm[a+1][b+1][i+1][j+1],(b-1.5*number)*resolution+(j+1)*4);
                    index++;}}}}
    for(int i=0;i<3*number;i++){for(int j=0;j<3*number;j++){migrate_quadsm(i,j);}}

//краска

    Handle seaside_tex=xLoadTexture("tex/Gravel01.jpg");
    Handle lgrass_tex=xLoadTexture("tex/Grass01.jpg");
    Handle dgrass_tex=xLoadTexture("tex/Grass02.jpg");
    Handle plain_tex=xLoadTexture("tex/Gravel02.jpg");
    Handle lmountain_tex=xLoadTexture("tex/dirt01.jpg");
    Handle mmountain_tex=xLoadTexture("tex/rock01.jpg");
    Handle hmountain_tex=xLoadTexture("tex/snow02.jpg");
    Handle smountain_tex=xLoadTexture("tex/snow01.jpg");
    Handle rock_tex=xLoadTexture("tex/rockn.jpg");

    Handle Shader=xLoadFXFile("shader/landpainter.fx");

    xSetEntityEffect(surf->mesh,Shader);
    xSetEffectTexture(surf->mesh,"seaside",seaside_tex);
    xSetEffectTexture(surf->mesh,"lgrass",lgrass_tex);
    xSetEffectTexture(surf->mesh,"dgrass",dgrass_tex);
    xSetEffectTexture(surf->mesh,"plain",plain_tex);
    xSetEffectTexture(surf->mesh,"lmountain",lmountain_tex);
    xSetEffectTexture(surf->mesh,"mmountain",mmountain_tex);
    xSetEffectTexture(surf->mesh,"hmountain",hmountain_tex);
    xSetEffectTexture(surf->mesh,"smountain",smountain_tex);
    xSetEffectTexture(surf->mesh,"rockn",rock_tex);

    xSetEffectTechnique(surf->mesh, "Diffuse");
    xSetEffectFloat(surf->mesh,"scale",0.3);

    xSetEntityEffect(surfm->mesh,Shader);
    xSetEffectTexture(surfm->mesh,"seaside",seaside_tex);
    xSetEffectTexture(surfm->mesh,"lgrass",lgrass_tex);
    xSetEffectTexture(surfm->mesh,"dgrass",dgrass_tex);
    xSetEffectTexture(surfm->mesh,"plain",plain_tex);
    xSetEffectTexture(surfm->mesh,"lmountain",lmountain_tex);
    xSetEffectTexture(surfm->mesh,"mmountain",mmountain_tex);
    xSetEffectTexture(surfm->mesh,"hmountain",hmountain_tex);
    xSetEffectTexture(surfm->mesh,"smountain",smountain_tex);
    xSetEffectTexture(surfm->mesh,"rockn",rock_tex);

    xSetEffectTechnique(surf->mesh, "Diffuse");
    xSetEffectFloat(surf->mesh,"scale",0.3);


    }



А ведь на глаз разницы нету.

impersonalis 27.10.2011 00:32

Ответ: Странное.
 
Код:

А ведь на глаз разницы нету.
Ох.. а ещё бывает проведёшь "ацкую" оптимизацию: убьёшь день-два на рефакторинг и иные реализации. Причём всё сделаешь так, что новый супералгоритм будет выдавать такую же красивую картинку как и предшествующий супер-шейдер-мультитекстур-дот-паралакс-бампинг, но быстрее в несколько раз / без юзания внешних библиотек / со стабильным фпс / код мультиплатформенный / код сверхуниверсальный (нужное подчеркнуть).
Сторонний наблюдатель посмотрит-посмотрит, и скажет так, с пренебрежением:
- мндээ - ну и что ты два дня делал?!
:blink: :''(( >>:(

По коду мельком:
- лучше в объявлении класса писать только пропиты* методов;
- в методах, при обращении к членам класса, лучше использовать синтаксис this->
Код:

this->x=a;
это:
+убирает неоднозначность при совпадении имён (можешь дать аргументам адекватные имена x,y,z);
+большинство IDE будет подсказывать (выводить список) членов класса: меньше опечаток и загруженности человеку;
+код более нагляден.

апд: * - прототипы имелось в виду, вот так опечатка

dsd 27.10.2011 23:52

Ответ: Странное.
 

Игрался с чужими картинками и нормалями, захотелось сделать генератор бесшовных текстур плавно изменяющегося градиента независимо для трех каналов цвета. Причем, чтобы он от 0.5 рисовал в обе стороны :rolleyes:

dsd 28.10.2011 20:53

Ответ: Странное.
 
Написал генератор отклонения нормали от нормального положения для шейдераф. Бесшовный. Быстрый относительно. С настройками.



int ARGB (int a,int r,int b, int g){
int color=(a<<24)+(r<<16)+(b<<8)+g;
return color;
}
//генератор градиентного трехканального шума
Handle GrimMagicPikcha(int size, double sharp, int seed){

xSeedRnd(seed);
//создается массив для значений

double **m0[size+1];
for(int i=0;i<=size;i++){m0[i]= new double*[size+1];}
for(int i=0;i<=size;i++){
for(int j=0;j<=size;j++){
m0[i][j]= new double[3];}}


for(int k=0;k<3;k++){

for(int i=0;i<=size;i++){
for(int j=0;j<=size;j++){
m0[i][j][k]=0;
}
}
//заполнение краев случайными числами (-5;5)
m0[0][0][k]=xRnd(-5,5);
m0[size][0][k]=xRnd(-5,5);
m0[0][size][k]=xRnd(-5,5);
m0[size][size][k]=xRnd(-5,5);

int step=size>>1;
while(step>0){
//первая строка
for(int i=step;i<=size-step;i=i+2*step){
for(int j=step;j<=size-step;j=j+2*step){

//вычисление необходимых индексов
int x0=i-step;
if(x0<0){x0=x0+size;}
int x1=i+step;
if(x1>=size){x1=x1-size;}
int y0=j-step;
if(y0<0){y0=y0+size;}
int y1=j+step;
if(y1>=size){y1=y1-size;}

double val00=m0[x0][y0][k];
double val01=m0[x0][y1][k];
double val10=m0[x1][y0][k];
double val11=m0[x1][y1][k];

if(m0[i][j][k]==0 && val00!=0 && val01!=0 && val10!=0 && val11!=0){
m0[i][j][k]=0.25*(val00+val01+val10+val11)+step*xRnd(-sharp,sharp);
m0[x0][j][k]=0.5*(val00+val01)+0.5*step*xRnd(-sharp,sharp);
m0[x1][j][k]=0.5*(val10+val11)+0.5*step*xRnd(-sharp,sharp);
m0[i][y0][k]=0.5*(val00+val10)+0.5*step*xRnd(-sharp,sharp);
m0[i][y1][k]=0.5*(val01+val11)+0.5*step*xRnd(-sharp,sharp);}
}
}
step=step>>1;
}
//приведение значений в массивах в интервал (0;1)
double max=0;
double min=0;
for (int i=0;i<=size;i++){
for (int j=0;j<=size;j++){
if(m0[i][j][k]>=max){max=m0 [i][j][k];}
if(m0[i][j][k]<=min){min=m0 [i][j][k];}
}
}

double length=max-min;
for (int i=0;i<=size;i++){
for (int j=0;j<=size;j++){
m0[i][j][k]=(m0 [i][j][k]-min)/length;
}
}
}

//*************************************
//дальше вывод значений
Handle tex=xCreateTexture(size,size);
xSetBuffer(xTextureBuffer(tex));
xLockBuffer(xTextureBuffer(tex));
for (int i=0;i<size;i++){
for (int j=0;j<size;j++){
double val0=m0 [i][j][0];
double val1=m0 [i][j][1];
double val2=m0 [i][j][2];
xWritePixelFast(i,j,ARGB(255,val0*255,val1*255,val 2*255),xTextureBuffer(tex));
}
}
xSetBuffer(xBackBuffer());
xUnlockBuffer(xTextureBuffer(tex));

return tex;

}

dsd 29.10.2011 15:25

Ответ: Странное.
 

Как очень легко накодил це:
Код:

class base_point{
public:
int x;
int y;
float val;

};
class temp_data{
public:
//вес и index
float w0;
int v0;
float w1;
int v1;
float w2;
int v2;
float w3;
int v3;

//конструктор задающий нули в поля
temp_data(){
w0=0;
v0=0;
w1=0;
v1=0;
w2=0;
v2=0;
w3=0;
v3=0;
}
};


class map_matrix{
public:
int size;
//массив базовых точек
base_point *mas;
//массив для временных значений
temp_data **temp;
//результирующий граиент значений
float **result;

//текстура
Handle tex;

map_matrix(int a){
    size=a;
    //число базовых точек
    int number=150;
    mas=new base_point[number];
    //запись в точки
    for(int i=0;i<number;i++){
    mas[i].val=xRnd(-5,5);
    mas[i].x=xRand(0,size);
    mas[i].y=xRand(0,size);}

    temp=new temp_data*[size+1];
    for(int i=0;i<=size;i++){temp[i]=new temp_data[size+1];}

    //вычисление максимальной дистанции
    float dist0=size*sqrt(2.0);

    for(int i=0;i<=size;i++){
        for(int j=0;j<=size;j++){

            //индексы с предельными значениями весов
            int i0,i1,i2,i3;
            float we0=0;
            float we1=0;
            float we2=0;
            float we3=0;
            for(int k=0;k<number;k++){
              int x=mas[k].x;
              int y=mas[k].y;
              float dist=sqrt((x-i)*(x-i)+(y-j)*(y-j));
              float weight=(dist0-dist)/dist0;
              //some kind of sort
              if(weight>=we0){we3=we2;we2=we1;we1=we0;we0=weight; i3=i2;i2=i1;i1=i0;i0=k;}
              if(weight>=we1){we3=we2;we2=we1;we1=weight;i3=i2;i2=i1;i1=k;}
              if(weight>=we2){we3=we2;we2=weight;i3=i2;i2=k;}
              if(weight>=we3){we3=weight;i3=k;}}
            //для текущей точки i,j есть соседи
            //пишем их в временную дату
            temp[i][j].v0=i0;
            temp[i][j].w0=we0;
            temp[i][j].v1=i1;
            temp[i][j].w1=we1;
            temp[i][j].v2=i2;
            temp[i][j].w2=we2;
            temp[i][j].v3=i3;
            temp[i][j].w3=we3;
        }
    }

//предварительная дата готова
//теперь нужно создать и посчитать итоговый массив данных
    result=new float*[size+1];
    for(int i=0;i<=size;i++){result[i]=new float[size+1];}
//calculations
    for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){
        //смотрю в базовые точки
        float val0=mas[temp[i][j].v0].val; float we0=temp[i][j].w0;
        float val1=mas[temp[i][j].v1].val; float we1=temp[i][j].w1;
        float val2=mas[temp[i][j].v2].val; float we2=temp[i][j].w2;
        float val3=mas[temp[i][j].v3].val; float we3=temp[i][j].w3;
        float mval=val0*we0+val1*we1+val2*we2+val3*we3;

        //складываю квадраты весов.
        float weights=we0+we1+we2+we3;
        result[i][j]=mval/weights;
    }}
//to 0,1
float min=100000;
float max=-100000;
    for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){
      if(result[i][j]>max){max=result[i][j];}
      if(result[i][j]<min){min=result[i][j];}
    }}

for(int i=0;i<=size;i++){for(int j=0;j<=size;j++){
    result[i][j]=(result[i][j]-min)/(max-min);
}}
//вывод в текстуру

tex=xCreateTexture(size,size);
xSetBuffer(xTextureBuffer(tex));
xLockBuffer(xTextureBuffer(tex));
for (int i=0;i<size;i++){
    for (int j=0;j<size;j++){
        float val0=result[i][j];

      xWritePixelFast(i,j,ARGB(255,val0*255,val0*255,val0*255),xTextureBuffer(tex));
    }
}
xSetBuffer(xBackBuffer());
xUnlockBuffer(xTextureBuffer(tex));


}

};



dsd 29.10.2011 23:49

Ответ: Странное.
 

На деревяшки чисто по форме поверхности похоже или нет?

NitE 29.10.2011 23:55

Ответ: Странное.
 
На сосны.

dsd 29.10.2011 23:56

Ответ: Странное.
 
То есть иллюзия именно бревна покрытого корой, а не просто столбов с бугристой поверхностью?

Подайте люди добрые модельку анимированную в б3д какого-нибудь гуманоида, на опыты. Чтобы была анимация ходьбы, шаги в сторону, бег и ну и рукой дрыгал угрожающе, а если еще и руками потирать сможет вообще сказка :rolleyes:

NitE 30.10.2011 00:55

Ответ: Странное.
 
Вообщем - да. Попробуй на всё это дело налепить ещё фототекстуру.

Mr_F_ 30.10.2011 02:55

Ответ: Странное.
 
Цитата:

Вообщем - да. Попробуй на всё это дело налепить ещё фототекстуру.
если детали текстуры не будет совпадать с деталяим геометрии, то фейл. тут либо процедурная текстура, либо геометрия на основе реал тексы.

dsd 30.10.2011 12:13

Ответ: Странное.
 
Ну вообще я планировал сделать цилиндр 8х8, и дальше наложить более высокого разрешения текстуру на основе которой сделать нечто вроде бампа, для рельефа, а когда есть рельеф то сама фактура коры похожа на это:

Нужно только пару параметров подобрать, мне в принципе не важна фотореалистичность.


Часовой пояс GMT +4, время: 22:30.

vBulletin® Version 3.6.5.
Copyright ©2000 - 2025, Jelsoft Enterprises Ltd.
Перевод: zCarot