what should i do after generating the perlin noise value?

[hsunteik]

after generating the 3d perlin noise value(x,y and z respectively(the value is between -1 and 1)),how do i use the generated value to create texture or terrain?

note that i am using opengl.

[Mekire]

Looks like a good place to start:
http://www.redblobgames.com/maps/terrain-from-noise/

[hsunteik]

Looks like a good place to start:  
http://www.redblobgames.com/maps/terrain-from-noise/

the website that you gave is not python,but it is ok.

does it teach me to draw the terrain?
i just see the usage of the keyword "return".
does "return"draw the terrain,i thought "return" is for causing your function to exit and hand back a value to its caller?

part of the website you gave:

function biome(e) {
   if (e < 0.76) return WATER;
   else return LAND;
}

[Mekire]

Your post is also not particularly about python. But yes, there is python in the link provided. Either way that site is an amazing resource for game programmers. Try actually reading through it and you will understand a lot more than you did before.

Posts need to show effort and I pointed you in the direction you need to go.
No one is going to provide you with rendering code based on your first post.

[hsunteik]

No one is going to provide you with rendering code based on your first post.

can i have the rendering/terrain drawing code?
or some tutorial ?

and,how do i use Whittaker Diagram with perlin noise to generate biomes stuff?

[Mekire]

Okay, well I'm not going to try to do any OpenGL on the fly so this is the best you'll get from me.  Honestly you are getting into a realm where you need to start doing actual research.  Regarding the Whitaker diagrams I am afraid I don't know.

Here is some pygame code that generates some terrain based on noise.  You just draw different terrain tiles based on different noise values.  Requires pygame and opensimplex (installable via pip)
Result:
http://imgur.com/nd5lna0
Code:

Hide/Show

import sys
import random
import pygame as pg
import opensimplex as simp


SCREEN_SIZE = 500, 500
TILE_SIZE = 1, 1
BACKGROUND = pg.Color("darkslategray")
FPS = 60

WIDTH = SCREEN_SIZE[0]//TILE_SIZE[0]
HEIGHT = SCREEN_SIZE[1]//TILE_SIZE[1]


TERRAIN = [("water", 0.2), ("beach", 0.3), ("forest", 0.4), ("jungle", 0.5),
           ("savannah", 0.7), ("desert", 0.9), ("snow", 1)]


TERRAIN_COLORS = {"water" : pg.Color("lightblue"),
                  "beach" : pg.Color("tan"),
                  "forest" : pg.Color("forestgreen"),
                  "jungle" : pg.Color("darkgreen"),
                  "savannah" : pg.Color("sienna"),
                  "desert" : pg.Color("lightyellow"),
                  "snow" : pg.Color("snow")}


def noise(gen, nx, ny, freq=10):
    # Rescale from -1.0:+1.0 to 0.0:1.0
    return gen.noise2d(freq*nx, freq*ny) / 2.0 + 0.5


def gen_noise(gen, freq=10):
    vals = {}
    for y in range(WIDTH):
        for x in range(HEIGHT):
            nx = float(x)/WIDTH - 0.5
            ny = float(y)/HEIGHT - 0.5
            vals[x,y] = noise(gen, nx, ny, freq)
    return vals
            

class App(object):
    def __init__(self):
        self.screen = pg.display.get_surface()
        self.screen_rect = self.screen.get_rect()
        self.clock = pg.time.Clock()
        self.done = False
        self.seed = random.randrange(2**32)
        freq = random.randrange(5, 10)
        noise = gen_noise(simp.OpenSimplex(self.seed), freq)
        self.terrain = self.gen_map(noise) 

    def update(self):
        """
        All updates to all actors occur here.
        Exceptions include things that are direct results of events which
        may occasionally occur in the event loop.

        For example, updates based on held keys should be found here, but
        updates to single KEYDOWN events would be found in the event loop.
        """
        pass

    def gen_map(self, noise):
        mapping = pg.Surface(SCREEN_SIZE).convert()
        for x,y in noise:
            pos = TILE_SIZE[0]*x, TILE_SIZE[1]*y
            for biome, tolerance in TERRAIN:
                if noise[x,y] < tolerance:
                    mapping.fill(TERRAIN_COLORS[biome], (pos, TILE_SIZE))
                    break
        return mapping

    def render(self):
        """
        All calls to drawing functions here.
        No game logic.
        """
        self.screen.blit(self.terrain, (0,0))
        pg.display.update()

    def event_loop(self):
        """
        Event handling here.  Only things that are explicit results of the
        given events should be found here.  Do not confuse the event and update
        phases.
        """
        for event in pg.event.get():
           if event.type == pg.QUIT:
               self.done = True

    def main_loop(self):
        """
        Main loop for your whole app.  This doesn't need to be touched until
        you start writing framerate independant games.
        """
        while not self.done:
            self.event_loop()
            self.update()
            self.render()
            self.clock.tick(FPS)


def main():
    """
    Prepare pygame and the display and create an App instance.
    Call the app instance's main_loop function to begin the App.
    """
    pg.init()
    pg.display.set_mode(SCREEN_SIZE)
    App().main_loop()
    pg.quit()
    sys.exit()


if __name__ == "__main__":
    main()

[hsunteik]

thanks for your help...
actually,i have done many research ,but none of them actually teach me how to draw ,except one video that is made from c++ or c#,which i dont understand.

[Mekire]

If you are getting into openGL and 3d graphics honestly you are going to need to get used to reading other languages.
For instance here is a great tutorial book on openGL, but it is in C++
(linking to a repo of mine where I have a copy as the guy's site went down a few years back)
https://github.com/Mekire/gltut-pygame/b...lsComp.pdf

The http://www.redblobgames.com/ site I previously linked has tons of stuff.
There is also a really nice book on programming patterns specifically for game devs here:
http://gameprogrammingpatterns.com/contents.html

If you refuse to look at a book because it isn't in python you really will miss out on a lot of great information.
In the end programming is all the same (within reason).

[hsunteik]

Mekire,I have another question.
what if I want to draw a 3d shape instead of just filling the surface with pygame.surface.fill where I need to specify the coordinate,how would I do that?

---

Anyone,help please??☺?