It is currently Mon Dec 09, 2019 6:51 pm


All times are UTC




Post new topic Reply to topic  [ 17 posts ]  Go to page 1, 2  Next
Author Message
 Post subject: Procedural texturing problems
PostPosted: Fri Oct 02, 2015 11:17 pm 

Joined: Thu Apr 10, 2014 9:55 am
Posts: 7
Hi there,

So finally this is my first post here. :) Let me introduce myself first in a short manner: I am a lonesome programmer who has been experimenting with a bigger Project of myself since the last 2 years. I am using PolyVox in it for the purpose of having a destructible terrain and at that is does a marvellous job. :D

Also i would like to express my admiration for how nicely this community works together, then even if it is not that big, i was able to learn a lot here, since david, matt and all you others here are communicating very openly and very kindly. Until now i never had to ask a question on how to do what i wanted, because i could find every bit of information i needed here in the forums.

From here on i'll go straight to my problem: When i try to use a procedurally generated 3D-texture on a mesh i generate with PolyVox, i get distortions. To narrow down the problem, i used a cube mesh which is consisting of 64 voxels in each direction and a cube mesh in simlar size which is directly generated by the irrlicht engine for comparison. The irrlicht mesh has no distortion. As can be seen in the attached screenshots, the cube texture which is generated with PolyVox has a distortion on three faces. The screenshots show the positions from which the cube is watched at: x:0;y:0;z:0 at x:63;y:63,z:0; and at x:63;y:63;z:63;

To clarify: the "texture" is generated in a glsl fragment shader by using 3D simplex noise. The purpose of this is to be able to have realistic textures, which use no memory, and especially important for me, have no loading time to the gpu.

For those who are interested in how i use the 3D-noise conceptually: You need to imagine a block of some material, let's say granyte for example. Out of this an object, let's say the famous utah teapot, is carved out, more or less like a stonemason would do in RL. The generation of the texture happens pixel by pixel in a fragment shader. The single pixel get's a color which is based on the pseudo random noise value which is calculated on the base of the Vertex position.
This has a lot of advantages: You can produce textures that are infinitely large, but take up almost no memory. They can be applied to any shaped object without distortion (or should be in my case). You can create rock, wood, swirly patterns, etc... probably anything can be generated. And last but not least you can make it look like an object is "made out of" some material. The results can be very impressive, but it needs patience and lot of fiddling around. ;)

Please excuse my potentially bad english, since it is not my mother tongue.


Attachments:
cube_distorted_x63y63z63.png
cube_distorted_x63y63z63.png [ 54.58 KiB | Viewed 10150 times ]
cube_distorted_x63y63z0.png
cube_distorted_x63y63z0.png [ 56.11 KiB | Viewed 10150 times ]
cube_distorted_x0y0z0.png
cube_distorted_x0y0z0.png [ 58.77 KiB | Viewed 10150 times ]
Top
Offline Profile  
Reply with quote  
 Post subject: Re: Procedural texturing problems
PostPosted: Sat Oct 03, 2015 12:01 am 

Joined: Thu Apr 10, 2014 9:55 am
Posts: 7
Some more information: I use PolyVox 0.2.1. The volume is a RawVolume. The Mesh is extracted with the marching cubes extractor, but not smoothed further. The output from the extraction is converted the following way to an Irrlicht mesh:

Code:
scene::SMesh* convertMesh(const PolyVox::SurfaceMesh<PolyVox::PositionMaterialNormal>* pMesh, video::SColor vertexColor)
{
   scene::SMesh* pIrrMesh = new scene::SMesh;
   const std::vector<uint32_t>& indices = pMesh->getIndices();
   const std::vector<PolyVox::PositionMaterialNormal>& vertices = pMesh->getVertices();
   
   scene::IDynamicMeshBuffer *pMeshBuffer = new scene::CDynamicMeshBuffer(video::EVT_STANDARD, video::EIT_16BIT);
   const uint_fast16_t numVertices = vertices.size();
   const uint_fast16_t numIndices = indices.size();
   
   video::S3DVertex VertexCoords;
   
   PolyVox::Vector3DFloat position;
   PolyVox::Vector3DFloat normal;
      
   pMeshBuffer->getVertexBuffer().set_used(numVertices);
   for (uint_fast16_t i = 0; i < numVertices; ++i) {
      position = vertices[i].getPosition();
      normal = vertices[i].getNormal();
      VertexCoords = pMeshBuffer->getVertexBuffer()[i];
      VertexCoords.Pos.set(position.getX(), position.getY(), position.getZ());
      VertexCoords.Normal.set(normal.getX(), normal.getY(), normal.getZ());
      VertexCoords.TCoords.set(position.getX(), position.getY());
      VertexCoords.Color = vertexColor;
      pMeshBuffer->getVertexBuffer()[i] = VertexCoords;
   }

   pMeshBuffer->getIndexBuffer().set_used(numIndices);
   for (uint_fast16_t i = 0; i < numIndices; ++i) {
      pMeshBuffer->getIndexBuffer().setValue(i, indices[i]);
   }
   
   pMeshBuffer->recalculateBoundingBox();
   pIrrMesh->addMeshBuffer(pMeshBuffer);
   pIrrMesh->recalculateBoundingBox();
   
    pIrrMesh->setHardwareMappingHint(irr::scene::EHM_STATIC);/*
    irr::scene::IMeshManipulator* pMeshManipulator = m_pSceneMgr->getMeshManipulator();
    pMeshManipulator->heightmapOptimizeMesh(pIrrMesh);
   return (scene::SMesh*)pMeshManipulator->createMeshWelded(pIrrMesh);*/
    return pIrrMesh;
}


Edit: I also tried with the newest Polyvox from the development branch, but it had the same result.


Top
Offline Profile  
Reply with quote  
 Post subject: Re: Procedural texturing problems
PostPosted: Sat Oct 03, 2015 7:00 am 
Developer
User avatar

Joined: Sun May 04, 2008 6:35 pm
Posts: 1827
Very interesting stuff! I think that the problem is most likely related to the vertex/fragment shader, or perhaps to the way that the shader is interpreting the data from PolyVox. Can you post the shader code here? Also:

  • Are you using the same shader for Irrlicht/PolyVox versions?
  • What inputs are you using? Is a fragments color calculated using only the position of the vertices, or do you also use normals, texture coordinates, etc?
  • If you only use positions, can you visualize the XYZ of each fragment as RGB components to see if they are correct? Do this for both the PolyVox and Irrlicht cubes?
  • Can you do a wireframe rendering of the Irrlicht and PolyVox cubes? Maybe this shows something interesting.

I hope that gives you some pointers in the right direction.


Top
Offline Profile  
Reply with quote  
 Post subject: Re: Procedural texturing problems
PostPosted: Sat Oct 03, 2015 6:01 pm 

Joined: Thu Apr 10, 2014 9:55 am
Posts: 7
Hi David,

Thanks for your answer.

1. Yes i am using the same shader for the PolyVox cube and the irrlicht cube.
2. The input is normalize(gl_Vertex.xyz) which i pass to a varying variable in the vertex shader, so that i can use it in the fragment shader. The x, y, and z positions are then multiplied with a frequency value to add noise detail, e.g. known as fractal brownian motion. The multiplied positions are passed as input for the 3D-simplexnoise function. See the function calculateFBM in the fragment shader.
3. I attached the the screenshots in wireframe and visualized RGB, see attachments and following posts. The visualized RGB images are also in wireframe. I hope i understood you correctly, for RGB visualization i simply pass the vertex positions directly to gl_FragColor: e.g. gl_FragColor = vec4(vTexCoord3D.xyz, 1.0);
4. The shader code:
Vertex shader:
Code:
#version 120

// vertex positions for 3D-noise
varying vec3 vTexCoord3D;

// variables for lighting model
uniform vec3 camPos; 
uniform vec3 lightPosition;
varying vec3 lightPos;
varying vec4 lightdiffuse;
varying vec4 lightambient;
varying vec3 lightnormal;
varying vec3 lightHV;

void computeVertexLight()
{
    /* first transform the normal into eye space and normalize the result */
    lightnormal = gl_Normal;
    lightPos = lightPosition;
   
    /* compute the vertex position  in camera space. */
    vec4 pos = gl_ModelViewMatrix * gl_Vertex;
    vec3 eyeVect = normalize(camPos - vec3(pos.xyz));
    lightHV = normalize(normalize(lightPosition) + eyeVect) * 0.5;
 
    /* Compute the diffuse, ambient and globalAmbient terms */
    lightdiffuse = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;
    lightambient = gl_FrontMaterial.ambient * gl_LightSource[0].ambient;
    lightambient += gl_LightModel.ambient * gl_FrontMaterial.ambient;
}

void main()
{
    //computeVertexLight();
    vTexCoord3D = normalize(gl_Vertex.xyz);
    gl_Position = ftransform();
}


Fragment shader:
Code:
#version 120

varying vec3 vTexCoord3D;

varying vec3 lightPos;
varying vec4 lightdiffuse;
varying vec4 lightambient;
varying vec3 lightnormal;
varying vec3 lightHV;

// ================================================================================
// 3D Simplex noise, courtesy of Stefan Gustavson and Ian McEwan fromm Ashima Arts.
// Copyright (C) 2011 Ashima Arts. Distributed under the MIT License.
// ================================================================================
vec4 mod289(vec4 x)
{
    return x - floor(x * 0.003460208) * 289.0;
}

vec3 mod289(vec3 x)
{
    return x - floor(x * 0.003460208) * 289.0;
}

vec4 permute(vec4 x)
{
    return mod289(((x * 34.0) + 1.0) * x);
}

vec4 taylorInvSqrt(vec4 r)
{
    return 1.79284291400159 - 0.85373472095314 * r;
}

float simplexNoise3D(vec3 v)
{
    const vec2  C = vec2(0.1666, 0.3333) ;
    const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);

    // First corner
    vec3 i  = floor(v + dot(v, C.yyy) );
    vec3 x0 =   v - i + dot(i, C.xxx) ;

    // Other corners
    vec3 g = step(x0.yzx, x0.xyz);
    vec3 l = 1.0 - g;
    vec3 i1 = min( g.xyz, l.zxy );
    vec3 i2 = max( g.xyz, l.zxy );

    //   x0 = x0 - 0.0 + 0.0 * C.xxx;
    //   x1 = x0 - i1  + 1.0 * C.xxx;
    //   x2 = x0 - i2  + 2.0 * C.xxx;
    //   x3 = x0 - 1.0 + 3.0 * C.xxx;
    vec3 x1 = x0 - i1 + C.xxx;
    vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
    vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y

    // Permutations
    i = mod289(i);
    vec4 p = permute( permute( permute(
                i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
              + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
              + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));

    // Gradients: 7x7 points over a square, mapped onto an octahedron.
    // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
    float n_ = 0.142857142857; // 1.0/7.0
    vec3  ns = n_ * D.wyz - D.xzx;

    vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)

    vec4 x_ = floor(j * ns.z);
    vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)

    vec4 x = x_ *ns.x + ns.yyyy;
    vec4 y = y_ *ns.x + ns.yyyy;
    vec4 h = 1.0 - abs(x) - abs(y);

    vec4 b0 = vec4( x.xy, y.xy );
    vec4 b1 = vec4( x.zw, y.zw );

    //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
    //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
    vec4 s0 = floor(b0)*2.0 + 1.0;
    vec4 s1 = floor(b1)*2.0 + 1.0;
    vec4 sh = -step(h, vec4(0.0));

    vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
    vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;

    vec3 p0 = vec3(a0.xy,h.x);
    vec3 p1 = vec3(a0.zw,h.y);
    vec3 p2 = vec3(a1.xy,h.z);
    vec3 p3 = vec3(a1.zw,h.w);

    //Normalise gradients
    vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
    p0 *= norm.x;
    p1 *= norm.y;
    p2 *= norm.z;
    p3 *= norm.w;

    // Mix final noise value
    vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
    m = m * m;
   
    return 42.0 * dot(m * m, vec4(dot(p0, x0), dot(p1, x1),
                                  dot(p2, x2), dot(p3, x3)));
}
// ================================================================================


vec3 RGBConv(vec3 rgb)
{
    return vec3(rgb.r * 0.003921569, rgb.g * 0.003921569, rgb.b * 0.003921569);
}

vec4 RGBAConv(vec4 rgba)
{
    return vec4(rgba.r * 0.003921569, rgba.g * 0.003921569, rgba.b * 0.003921569, rgba.a * 0.003921569);
}

// apply fractal Brownian motion
float calculateFBM(vec3 coord, float persistence,  float numOctaves, float frequency)
{
    float noiseVal = 0.0;
    float amplitude = 1;
   
    for (int i = 0; i < numOctaves; ++i) {
        noiseVal += simplexNoise3D(frequency * coord) * amplitude;
       
        frequency *= 2;
        amplitude *= persistence;
    }

    return noiseVal;
}

vec4 computePixelLight()
{   
    vec4 color = lightambient;
    vec3 lightDir = normalize(lightPos);
   
    /* a fragment shader can't write a varying variable, hence we need
    a new variable to store the normalized interpolated normal */
    vec3 n = normalize(lightnormal);
   
    // compute the dot product between normal and ldir
    float NdotL = max(dot(n, lightDir), 0.0);
   
    if (NdotL > 0.0) {
        color += lightdiffuse * NdotL;
        vec3 halfV = normalize(lightHV);
        float NdotHV = max(dot(n, halfV) ,0.0);
        color += vec4(0.0, 0.0, 0.0, 1.0) * pow(NdotHV, 0.0);
    }

    return color;
}

void main()
{
    float mixFactor = calculateFBM(vTexCoord3D, 0.5, 1, 16);
    float mixFactor2 = calculateFBM(vTexCoord3D, 1, 4, 16);
    float mixFactor3 = calculateFBM(vTexCoord3D, 0.0625, 1, 8);
   
    vec4 color1 = RGBAConv(vec4(237, 211, 161, 255));
    vec4 color2 = RGBAConv(vec4(161, 129, 69, 255));
   
    vec4 noiseColor1 = mix(color1, color2, mixFactor);
    vec4 noiseColor2 = mix(color2, color1, mixFactor2);
    vec4 noiseColor3 = mix(color1, color2, mixFactor3);
   
    vec4 col1 = mix(noiseColor1, noiseColor2, mixFactor3);
    vec4 col2 = mix(noiseColor1, noiseColor3, mixFactor3);
    vec4 col3 = mix(noiseColor2, noiseColor3, mixFactor3);
   
    gl_FragColor = col1 * col2 * col3;// * computePixelLight();
   
    //suggested rgb visualization by David Williams from volumesoffun.com
    //gl_FragColor = vec4(vTexCoord3D.xyz, 1.0);
}


Attachments:
cube_texture_polyvox_wireframe_x63y63z63.png
cube_texture_polyvox_wireframe_x63y63z63.png [ 99.19 KiB | Viewed 10139 times ]
cube_texture_polyvox_wireframe_x63y63z0.png
cube_texture_polyvox_wireframe_x63y63z0.png [ 119.66 KiB | Viewed 10139 times ]
cube_texture_polyvox_wireframe_x0y0z0.png
cube_texture_polyvox_wireframe_x0y0z0.png [ 125.41 KiB | Viewed 10139 times ]


Last edited by Sinsemilla on Sat Oct 03, 2015 6:27 pm, edited 1 time in total.
Top
Offline Profile  
Reply with quote  
 Post subject: Re: Procedural texturing problems
PostPosted: Sat Oct 03, 2015 6:04 pm 

Joined: Thu Apr 10, 2014 9:55 am
Posts: 7
Images for the RGB-Visualizations of the PolyVox cube in the attachments of this post.


Attachments:
cube_rgb_polyvox_wireframe_x63y63z63.png
cube_rgb_polyvox_wireframe_x63y63z63.png [ 116.82 KiB | Viewed 10139 times ]
cube_rgb_polyvox_wireframe_x63y63z0.png
cube_rgb_polyvox_wireframe_x63y63z0.png [ 96.07 KiB | Viewed 10139 times ]
cube_rgb_polyvox_wireframe_x0y0z0.png
cube_rgb_polyvox_wireframe_x0y0z0.png [ 101.16 KiB | Viewed 10139 times ]
Top
Offline Profile  
Reply with quote  
 Post subject: Re: Procedural texturing problems
PostPosted: Sat Oct 03, 2015 6:21 pm 

Joined: Thu Apr 10, 2014 9:55 am
Posts: 7
Images for the Texture in wireframe of the irrlicht cube in the attachments of this post.

@David: Thx a lot for the wireframe idea, i feel a little bit dumb that i didn't had it myself. At least i see now there is a very clear difference in how both meshes are built. I am not sure what i see here though, since i am not very experienced in mesh handling. So please correct me if i am wrong. If i understand this correctly the irrlicht mesh keeps always the same amount of vertices but moves them according to the mesh size, while the polyvox mesh becomes its vertices added by the amount of voxels and it's size is then the amount of voxels in each direction. I am not sure what to do here, since the vertex positions can't be simply re-scaled because that would mess up the Fractal browniam motion and thus the texture.


Attachments:
cube_texture_irrlicht_wireframe_x63y63z63.png
cube_texture_irrlicht_wireframe_x63y63z63.png [ 8.1 KiB | Viewed 10139 times ]
cube_texture_irrlicht_wireframe_x63y63z0.png
cube_texture_irrlicht_wireframe_x63y63z0.png [ 12.42 KiB | Viewed 10139 times ]
cube_texture_irrlicht_wireframe_x0y0z0.png
cube_texture_irrlicht_wireframe_x0y0z0.png [ 8.84 KiB | Viewed 10139 times ]
Top
Offline Profile  
Reply with quote  
 Post subject: Re: Procedural texturing problems
PostPosted: Mon Oct 05, 2015 6:04 pm 

Joined: Thu Apr 10, 2014 9:55 am
Posts: 7
I solved it :D

The trick is to pass the world transformation matrix and to multiply it with gl_Vertex.xyz in the vertex shader. In the fragment shader a texture scaling has to be applied then to these coordinates.

Vertex shader:
Code:
#version 120

varying vec3 vTexCoord3D;

uniform vec3 camPos; 
uniform vec3 lightPosition;
uniform mat4 worldTransMatrix;

varying vec3 lightPos;
varying vec4 lightdiffuse;
varying vec4 lightambient;
varying vec3 lightnormal;
varying vec3 lightHV;

void computeVertexLight()
{
    /* first transform the normal into eye space and normalize the result */
    lightnormal = gl_Normal;
    lightPos = lightPosition;
   
    /* compute the vertex position  in camera space. */
    vec4 pos = gl_ModelViewMatrix * gl_Vertex;
    vec3 eyeVect = normalize(camPos - vec3(pos.xyz));
    lightHV = normalize(normalize(lightPosition) + eyeVect) * 0.5;
 
    /* Compute the diffuse, ambient and globalAmbient terms */
    lightdiffuse = gl_FrontMaterial.diffuse * gl_LightSource[0].diffuse;
    lightambient = gl_FrontMaterial.ambient * gl_LightSource[0].ambient;
    lightambient += gl_LightModel.ambient * gl_FrontMaterial.ambient;
}

void main()
{
    //computeVertexLight();
    vTexCoord3D = (worldTransMatrix * gl_Vertex).xyz;
    gl_Position = ftransform();
}


Fragment shader:
Code:
#version 120

varying vec3 vTexCoord3D;

varying vec3 lightPos;
varying vec4 lightdiffuse;
varying vec4 lightambient;
varying vec3 lightnormal;
varying vec3 lightHV;

// ================================================================================
// 3D Simplex noise, courtesy of Stefan Gustavson and Ian McEwan fromm Ashima Arts.
// Copyright (C) 2011 Ashima Arts. Distributed under the MIT License.
// ================================================================================
vec4 mod289(vec4 x)
{
    return x - floor(x * 0.003460208) * 289.0;
}

vec3 mod289(vec3 x)
{
    return x - floor(x * 0.003460208) * 289.0;
}

vec4 permute(vec4 x)
{
    return mod289(((x * 34.0) + 1.0) * x);
}

vec4 taylorInvSqrt(vec4 r)
{
    return 1.79284291400159 - 0.85373472095314 * r;
}

float simplexNoise3D(vec3 v)
{
    const vec2  C = vec2(0.1666, 0.3333) ;
    const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);

    // First corner
    vec3 i  = floor(v + dot(v, C.yyy) );
    vec3 x0 =   v - i + dot(i, C.xxx) ;

    // Other corners
    vec3 g = step(x0.yzx, x0.xyz);
    vec3 l = 1.0 - g;
    vec3 i1 = min( g.xyz, l.zxy );
    vec3 i2 = max( g.xyz, l.zxy );

    //   x0 = x0 - 0.0 + 0.0 * C.xxx;
    //   x1 = x0 - i1  + 1.0 * C.xxx;
    //   x2 = x0 - i2  + 2.0 * C.xxx;
    //   x3 = x0 - 1.0 + 3.0 * C.xxx;
    vec3 x1 = x0 - i1 + C.xxx;
    vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
    vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y

    // Permutations
    i = mod289(i);
    vec4 p = permute( permute( permute(
                i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
              + i.y + vec4(0.0, i1.y, i2.y, 1.0 ))
              + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));

    // Gradients: 7x7 points over a square, mapped onto an octahedron.
    // The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294)
    float n_ = 0.142857142857; // 1.0/7.0
    vec3  ns = n_ * D.wyz - D.xzx;

    vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)

    vec4 x_ = floor(j * ns.z);
    vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)

    vec4 x = x_ *ns.x + ns.yyyy;
    vec4 y = y_ *ns.x + ns.yyyy;
    vec4 h = 1.0 - abs(x) - abs(y);

    vec4 b0 = vec4( x.xy, y.xy );
    vec4 b1 = vec4( x.zw, y.zw );

    //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0;
    //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0;
    vec4 s0 = floor(b0)*2.0 + 1.0;
    vec4 s1 = floor(b1)*2.0 + 1.0;
    vec4 sh = -step(h, vec4(0.0));

    vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
    vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;

    vec3 p0 = vec3(a0.xy,h.x);
    vec3 p1 = vec3(a0.zw,h.y);
    vec3 p2 = vec3(a1.xy,h.z);
    vec3 p3 = vec3(a1.zw,h.w);

    //Normalise gradients
    vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
    p0 *= norm.x;
    p1 *= norm.y;
    p2 *= norm.z;
    p3 *= norm.w;

    // Mix final noise value
    vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
    m = m * m;
   
    return 42.0 * dot(m * m, vec4(dot(p0, x0), dot(p1, x1),
                                  dot(p2, x2), dot(p3, x3)));
}
// ================================================================================


vec3 RGBConv(vec3 rgb)
{
    return vec3(rgb.r * 0.003921569, rgb.g * 0.003921569, rgb.b * 0.003921569);
}

vec4 RGBAConv(vec4 rgba)
{
    return vec4(rgba.r * 0.003921569, rgba.g * 0.003921569, rgba.b * 0.003921569, rgba.a * 0.003921569);
}

// apply fractal Brownian motion
float calculateFBM(vec3 coord, float persistence,  float numOctaves, float frequency)
{
    float noiseVal = 0.0;
    float amplitude = 1;

    for (int i = 0; i < numOctaves; ++i) {
        noiseVal += simplexNoise3D(frequency * coord) * amplitude;
       
        frequency *= 2;
        amplitude *= persistence;
    }

    return noiseVal;
}

vec4 computePixelLight()
{   
    vec4 color = lightambient;
    vec3 lightDir = normalize(lightPos);
   
    /* a fragment shader can't write a varying variable, hence we need
    a new variable to store the normalized interpolated normal */
    vec3 n = normalize(lightnormal);
   
    // compute the dot product between normal and ldir
    float NdotL = max(dot(n, lightDir), 0.0);
   
    if (NdotL > 0.0) {
        color += lightdiffuse * NdotL;
        vec3 halfV = normalize(lightHV);
        float NdotHV = max(dot(n, halfV) ,0.0);
        color += vec4(0.0, 0.0, 0.0, 1.0) * pow(NdotHV, 0.0);
    }

    return color;
}

void main()
{
    float mixFactor = calculateFBM(vTexCoord3D * (1.0 / 1024), 0.5, 1, 16);
    float mixFactor2 = calculateFBM(vTexCoord3D * (1.0 / 1024), 1, 4, 16);
    float mixFactor3 = calculateFBM(vTexCoord3D * (1.0 / 1024), 0.0625, 1, 8);
   
    vec4 color1 = RGBAConv(vec4(237, 211, 161, 255));
    vec4 color2 = RGBAConv(vec4(161, 129, 69, 255));
   
    vec4 noiseColor1 = mix(color1, color2, mixFactor);
    vec4 noiseColor2 = mix(color2, color1, mixFactor2);
    vec4 noiseColor3 = mix(color1, color2, mixFactor3);
   
    vec4 col1 = mix(noiseColor1, noiseColor2, mixFactor3);
    vec4 col2 = mix(noiseColor1, noiseColor3, mixFactor3);
    vec4 col3 = mix(noiseColor2, noiseColor3, mixFactor3);
   
    gl_FragColor = col1 * col2 * col3;// * computePixelLight();
}


Top
Offline Profile  
Reply with quote  
 Post subject: Re: Procedural texturing problems
PostPosted: Mon Oct 05, 2015 9:58 pm 
Developer
User avatar

Joined: Sun May 04, 2008 6:35 pm
Posts: 1827
Sinsemilla wrote:
The trick is to pass the world transformation matrix and to multiply it with gl_Vertex.xyz in the vertex shader.


Glad you solved it! This does indeed look like the right approach.


Top
Offline Profile  
Reply with quote  
 Post subject: Re: Procedural texturing problems
PostPosted: Thu Nov 05, 2015 4:46 am 
User avatar

Joined: Sun May 18, 2014 10:52 pm
Posts: 43
Sinsemilla wrote:
Also i would like to express my admiration for how nicely this community works together, then even if it is not that big, i was able to learn a lot here, since david, matt and all you others here are communicating very openly and very kindly. Until now i never had to ask a question on how to do what i wanted, because i could find every bit of information i needed here in the forums.


Amazing, I've been doing my own irrlicht polyvox stuff, I wonder how much of my work you have learned from. :D

And now I can get textures working finally with YOUR help. You said it friend, amazing community support!


Top
Offline Profile  
Reply with quote  
 Post subject: Re: Procedural texturing problems
PostPosted: Thu Nov 05, 2015 7:44 am 
User avatar

Joined: Sun May 18, 2014 10:52 pm
Posts: 43
Sinsemilla wrote:
Code:
   video::S3DVertex VertexCoords;
   
   PolyVox::Vector3DFloat position;
   PolyVox::Vector3DFloat normal;
      
   pMeshBuffer->getVertexBuffer().set_used(numVertices);
   for (uint_fast16_t i = 0; i < numVertices; ++i) {
      position = vertices[i].getPosition();
      normal = vertices[i].getNormal();
      VertexCoords = pMeshBuffer->getVertexBuffer()[i];
      VertexCoords.Pos.set(position.getX(), position.getY(), position.getZ());
      VertexCoords.Normal.set(normal.getX(), normal.getY(), normal.getZ());
      VertexCoords.TCoords.set(position.getX(), position.getY());
      VertexCoords.Color = vertexColor;
      pMeshBuffer->getVertexBuffer()[i] = VertexCoords;
   


Edit: I also tried with the newest Polyvox from the development branch, but it had the same result.


OHH HO HO YEAH! You are a GENIUS OP!

It worked, I now have my texture VERTEXCoords properly set.. well for 2 sides per voxel anyway :D

P.S. No shaders. but perhaps I'll add them ;)


Top
Offline Profile  
Reply with quote  
Display posts from previous:  Sort by  
Post new topic Reply to topic  [ 17 posts ]  Go to page 1, 2  Next

All times are UTC


Who is online

Users browsing this forum: No registered users and 11 guests


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Jump to:  
cron
Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group
Theme created StylerBB.net