आप टिलिबल पेरलिन शोर कैसे उत्पन्न करते हैं?

Question

सम्बंधित:

• साधारण शोर वाली पीढ़ी
• पेरलिन शोर को समझना

मैं टिलिबल पेरलिन शोर उत्पन्न करना चाहूंगा। मैं पॉल बॉर्के के PerlinNoise*() कार्यों से काम कर रहा हूं , जो इस प्रकार हैं:

// alpha is the "division factor" (how much to damp subsequent octaves with (usually 2))
// beta is the factor that multiplies your "jump" into the noise (usually 2)
// n is the number of "octaves" to add in
double PerlinNoise2D(double x,double y,double alpha,double beta,int n)
{
   int i;
   double val,sum = 0;
   double p[2],scale = 1;

   p[0] = x;
   p[1] = y;
   for (i=0;i<n;i++) {
      val = noise2(p);
      sum += val / scale;
      scale *= alpha;
      p[0] *= beta;
      p[1] *= beta;
   }
   return(sum);
}

जैसे कोड का उपयोग करना:

real val = PerlinNoise2D( x,y, 2, 2, 12 ) ; // test

return val*val*skyColor + 2*val*(1-val)*gray + (1-val)*(1-val)*cloudColor ;

जैसे आकाश देता है

जो देखने योग्य नहीं है।

पिक्सेल मान 0-6 (चौड़ाई और ऊंचाई), और पिक्सेल (0,0) का उपयोग करता है (x, y) = (0,0) और पिक्सेल (256,256) का उपयोग करता है (x, y) = (1,1)

मैं इसे कैसे तुलनीय बना सकता हूं?

Comments

बस FYI करें, आपके पास जो कुछ भी नहीं है वह Perlin शोर नहीं है; यह भग्न शोर है। पेर्लिन शोर संभवतया "शोर 2" कार्य है जो भग्न शोर के प्रत्येक सप्तक को उत्पन्न करता है।

— नाथन रीड

Answer 1

इस तरह सीमलेस टिलिबल एफबीएम शोर बनाने के दो भाग हैं। सबसे पहले, आपको पेरलिन शोर फ़ंक्शन को खुद को बनाने योग्य बनाने की आवश्यकता है। यहाँ एक सरल पेर्लिन शोर फ़ंक्शन के लिए कुछ पायथन कोड है जो किसी भी अवधि के साथ 256 तक काम करता है (आप पहले सेक्शन को संशोधित करके इसे जितना चाहें उतना बढ़ा सकते हैं):

import random
import math
from PIL import Image

perm = range(256)
random.shuffle(perm)
perm += perm
dirs = [(math.cos(a * 2.0 * math.pi / 256),
         math.sin(a * 2.0 * math.pi / 256))
         for a in range(256)]

def noise(x, y, per):
    def surflet(gridX, gridY):
        distX, distY = abs(x-gridX), abs(y-gridY)
        polyX = 1 - 6*distX**5 + 15*distX**4 - 10*distX**3
        polyY = 1 - 6*distY**5 + 15*distY**4 - 10*distY**3
        hashed = perm[perm[int(gridX)%per] + int(gridY)%per]
        grad = (x-gridX)*dirs[hashed][0] + (y-gridY)*dirs[hashed][1]
        return polyX * polyY * grad
    intX, intY = int(x), int(y)
    return (surflet(intX+0, intY+0) + surflet(intX+1, intY+0) +
            surflet(intX+0, intY+1) + surflet(intX+1, intY+1))

पेर्लिन का शोर थोड़ा "सरफलेट्स" के योग से उत्पन्न होता है जो एक यादृच्छिक रूप से उन्मुख ग्रेडिएंट और एक अलग पॉलीओनोमियल फ़ॉलऑफ़ फ़ंक्शन का उत्पाद होता है। यह एक सकारात्मक क्षेत्र (पीला) और नकारात्मक क्षेत्र (नीला) देता है

सर्फ़लेट्स में 2x2 की सीमा होती है और पूर्णांक जाली बिंदुओं पर केंद्रित होती है, इसलिए अंतरिक्ष में प्रत्येक बिंदु पर पेर्लिन शोर का मान सेल के कोनों पर सर्फ़लेट्स को समेट कर उत्पन्न होता है, जिस पर वह रहता है।

यदि आप कुछ अवधि के साथ ढाल दिशाओं को लपेटते हैं, तो शोर स्वयं उसी अवधि के साथ मूल रूप से लपेटेगा। यही कारण है कि ऊपर दिए गए कोड को क्रमांकन तालिका के माध्यम से हैशिंग से पहले जाली समन्वित मोड्यूलो की अवधि लेता है।

दूसरा कदम, यह है कि जब ओक्टेव को समेटना है तो आप ऑक्टेव की आवृत्ति के साथ अवधि को स्केल करना चाहेंगे। अनिवार्य रूप से, आप चाहते हैं कि प्रत्येक सप्तक पूरी छवि को एक बार टाइल करे, बजाय कई बार:

def fBm(x, y, per, octs):
    val = 0
    for o in range(octs):
        val += 0.5**o * noise(x*2**o, y*2**o, per*2**o)
    return val

एक साथ रखो और तुम कुछ इस तरह से मिलता है:

size, freq, octs, data = 128, 1/32.0, 5, []
for y in range(size):
    for x in range(size):
        data.append(fBm(x*freq, y*freq, int(size*freq), octs))
im = Image.new("L", (size, size))
im.putdata(data, 128, 128)
im.save("noise.png")

जैसा कि आप देख सकते हैं, यह वास्तव में निर्बाध रूप से टाइल करता है:

कुछ छोटे ट्विकिंग और कलर मैपिंग के साथ, यहां क्लाउड इमेज को 2x2 से टाइल किया गया है:

उम्मीद है की यह मदद करेगा!

Comments

एक अजगर आदमी नहीं हूँ, इसलिए मैं पूछता हूँ, x*2**oसी में कैसे परिवर्तित होता है? क्या यह है: x*pow(2,o)या pow(x*2,o)?

— vवद

x*pow(2, o), क्योंकि घातांक की तुलना में घातांक की उच्च प्राथमिकता है।

— जॉन कालसेक

क्या कोई इसे C में बदल सकता है? मुझे इस कोड को समझने में बड़ी समस्या है, क्योंकि मैंने अजगर के साथ कभी कुछ नहीं किया है। उदाहरण के लिए aमूल्य क्या है ? और यह सुनिश्चित न करें कि फ़ंक्शन सी में कैसे परिवर्तित होता है ... मुझे केवल आउटपुट में सीधी रेखाएं मिलती हैं।

— idev

यह निश्चित रूप से सबसे अच्छा समाधान है जब तक आप अपने शोर के डोमेन के साथ ठीक हो जाते हैं जब तक कि आपके टाइल के आकार से बंधा नहीं हो। उदाहरण के लिए, यह मनमाने घुमाव की अनुमति नहीं देता है। लेकिन अगर आपको ऐसी किसी चीज की जरूरत नहीं है, तो यह आदर्श उत्तर है।

— जॉन कैल्सबीक

नोट: यदि आप 128 से अन्य आकार उत्पन्न करना चाहते हैं, तो लाइन पर संख्यात्मक मान न बदलें im.putdata(data, 128, 128)। : (अजगर या जनहित याचिका के साथ अपरिचित उन लोगों के लिए वे पैमाने मतलब है और ऑफसेट, नहीं छवि का आकार।)

— अंटी Kissaniemi

Answer 2

यहाँ एक नहीं बल्कि चतुर तरीका है जो 4 डी पेर्लिन शोर का उपयोग करता है।

मूल रूप से, अपने पिक्सेल के X निर्देशांक को 2D सर्कल में मैप करें, और अपने पिक्सेल के Y को दूसरे 2D सर्कल में समन्वयित करें, और उन दोनों सर्कल को एक दूसरे से 4D स्थान पर ऑर्थोगोनल रखें। परिणामी बनावट टिलिबल है, इसमें कोई स्पष्ट विकृति नहीं है, और इस तरह से दोहराए नहीं जाते हैं कि एक प्रतिबिंबित बनावट होगी।

लेख से कॉपी-पेस्ट कोड:

for x=0,bufferwidth-1,1 do
    for y=0,bufferheight-1,1 do
        local s=x/bufferwidth
        local t=y/bufferheight
        local dx=x2-x1
        local dy=y2-y1

        local nx=x1+cos(s*2*pi)*dx/(2*pi)
        local ny=y1+cos(t*2*pi)*dy/(2*pi)
        local nz=x1+sin(s*2*pi)*dx/(2*pi)
        local nw=y1+sin(t*2*pi)*dy/(2*pi)

        buffer:set(x,y,Noise4D(nx,ny,nz,nw))
    end
end

Comments

यह निश्चित रूप से सही उत्तर है। आयाम जोड़ें एक पुराना गणितज्ञ चाल है। ऑलिंड रॉड्रिगोस डॉकिट (सर डब्ल्यूआर हैमिल्टन डॉकिट बहुत कम लेकिन थोड़ा कम)

— FxIII

@FxIII, क्या आप जानते हैं कि इस Noise4D () को कैसे लागू किया जाना चाहिए? मैं यह कोशिश करना चाहूंगा लेकिन मुझे कोई सुराग नहीं है कि यह Noise4D () कैसे काम करना चाहिए।

— idev

आप किसी भी 4 डी शोर समारोह का उपयोग कर सकते हैं। सिम्पलेक्स शोर मेरी सिफारिश होगी। webstaff.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf

— जॉन कैल्सबेक

धन्यवाद जॉन! यह काम कर गया, मीठा! किसी ने भी यह नहीं कहा, लेकिन: X1, y1, x2, y2 को लगता है कि स्केलिंग, बड़ी दूरी, विस्तृत शोर। अगर यह किसी की मदद करता है।

— idev

ध्यान दें कि यह बोबोबोबो के उत्तर के बराबर है: आपकी मैपिंग 2-टोरस को possible में एम्बेड करती है, जो कि मीट्रिक विकृतियों के बिना संभव है जब आप इसे ding में एम्बेड करते हैं।

— लेटबर्नआउट

Answer 3

ठीक है मैंने समझ लिया। इसका उत्तर 3 डी शोर में एक टोरस में चलना है , जिससे एक 2 डी बनावट उत्पन्न होती है।

कोड:

Color Sky( double x, double y, double z )
{
  // Calling PerlinNoise3( x,y,z ),
  // x, y, z _Must be_ between 0 and 1
  // for this to tile correctly
  double c=4, a=1; // torus parameters (controlling size)
  double xt = (c+a*cos(2*PI*y))*cos(2*PI*x);
  double yt = (c+a*cos(2*PI*y))*sin(2*PI*x);
  double zt = a*sin(2*PI*y);
  double val = PerlinNoise3D( xt,yt,zt, 1.5, 2, 12 ) ; // torus

  return val*val*cloudWhite + 2*val*(1-val)*gray + (1-val)*(1-val)*skyBlue ;
}

परिणाम:

एक बार:

और टाइल की गई:

Comments

यह थोड़े काम करता है, लेकिन ऐसा लगता है कि टोरस की वक्रता के कारण आपको विकृति का एक गुच्छा मिल रहा है।

— नाथन रीड

आप वास्तव में सिर्फ स्थिति को माप सकते हैं, लेकिन मुझे इस प्रश्न के सभी भयानक / रचनात्मक उत्तर पसंद हैं। एक ही काम करने के लिए कई अलग-अलग तरीके।

मैंने देखा कि आप वास्तव में 0-1 मूल्यों का उपयोग नहीं करना चाहते, लेकिन 0-0.9999 ... मान! इसलिए आप उपयोग करेंगे: x / चौड़ाई, y / ऊंचाई आदि अन्यथा सीम फ्लॉप मैच (विपरीत किनारों को समान पिक्सेल बनाता है)। यह भी लगता है कि PerlinNoise3D () फ़ंक्शन को परिणाम मान के लिए क्लैंपिंग की आवश्यकता है, या कुछ पिक्सेल मान अतिप्रवाह।

— idev

@ नथन, क्या आप जानते हैं कि विकृति को कैसे ठीक किया जाए?

— idev

@ श्रीदेव का मानना ​​है कि विकृति को ठीक करने का तरीका इस प्रश्न के शीर्ष उत्तर में 4D विधि का उपयोग करना है। ;)

— नातान रीड

Answer 4

एक साधारण तरीका है कि मैं शोर समारोह और दर्पण के उत्पादन लेने के लिए हो सकता है / यह एक छवि है कि दो बार आकार में फ्लिप है। यह स्पष्ट करना मुश्किल है कि यहाँ एक छवि है:

अब, इस मामले में, यह बहुत स्पष्ट है कि आपने क्या किया था जब आप इसे देखते हैं। मैं दो तरीकों के बारे में सोच सकता हूं (संभवतः :-)) इसका समाधान करें:

1. आप उस बड़ी छवि को ले सकते हैं और फिर उसके ऊपर कुछ और शोर उत्पन्न कर सकते हैं लेकिन (और मुझे यकीन नहीं है कि अगर यह संभव है) मध्य की ओर ध्यान केंद्रित किया जाता है (ताकि किनारों को समान रहें)। यह अतिरिक्त अंतर को जोड़ सकता है जो आपके मस्तिष्क को लगता है कि यह केवल दर्पण चित्र नहीं है।

2. (मुझे भी यकीन नहीं है कि यह संभव है) आप प्रारंभिक छवि को अलग तरीके से उत्पन्न करने के लिए शोर फ़ंक्शन के इनपुट के साथ फ़िडलिंग कर सकते हैं। आपको यह परीक्षण और त्रुटि के द्वारा करना होगा, लेकिन उन विशेषताओं की तलाश करें जो आपकी आंख को खींचती हैं जब आप इसे टाइल / मिरर करते हैं और फिर कोशिश करते हैं और इसे उत्पन्न नहीं करते हैं।

उम्मीद है की यह मदद करेगा।

Comments

बहुत अच्छा लेकिन बहुत सममित!

— बोब्बोबो

@ बोबोबोबो यही मैं सोच रहा था कि अन्य कदम कम हो जाएंगे। तो, आप इस पद्धति का उपयोग करके एक "आधार" उत्पन्न कर सकते हैं, और फिर इसे देखने के लिए पूरी चीज़ पर कुछ और विवरण जोड़ सकते हैं जैसे कि यह (नहीं) प्रतिबिंबित हो।

— रिचर्ड मार्स्केल - Drackir

जब आप इस तरह का काम करते हैं तो आपको कुछ अजीब पैटर्न मिलने लगते हैं। यह एक विशेष रूप से तितली की तरह दिखता है। आसान समाधान, हालांकि।

— 21

यह मेरा पहला दृष्टिकोण भी था, लेकिन इसमें एक समस्या है, यहाँ दिखाई दे रही है: dl.dropbox.com/u/6620757/noise_seam.png जैसा कि आप एक फ्लिप बाउंड्री पार करते हैं, आप शोर के कार्य में एक असंतुष्टि का कारण बनते हैं, तुरंत ढलान समारोह। यहां तक ​​कि अगर आप शीर्ष पर दूसरे शोर फ़ंक्शन को लागू करते हैं, तो भी आउटपुट में दिखाई दे सकता है।

— झेरिको

महान विचार। यह आसानी से एक पिक्सेल शेडर का उपयोग करने में किया जा सकता है त्रिकोण लहर : समारोहtex2d(abs(abs(uv.x)%2.0-1.0), abs(abs(uv.y)%2.0-1.0))

— tigrou

Answer 5

इस उत्तर का पहला संस्करण वास्तव में गलत था, मैंने इसे अपडेट कर दिया है

एक विधि जिसका मैंने सफलतापूर्वक उपयोग किया है, शोर डोमेन को टाइल किया जाता है। दूसरे शब्दों में, अपने बेस noise2()फंक्शन को आवधिक बनाएं । यदि noise2()आवधिक है और betaपूर्णांक है, तो परिणामस्वरूप शोर की अवधि समान होगी noise2()।

हम noise2()समय-समय पर कैसे कर सकते हैं ? अधिकांश कार्यान्वयन में, यह फ़ंक्शन किसी प्रकार के जाली शोर का उपयोग करता है। यही है, यह पूर्णांक निर्देशांक पर यादृच्छिक संख्या प्राप्त करता है, और उन्हें प्रक्षेपित करता है। उदाहरण के लिए:

function InterpolatedNoise_1D(float x)

  integer_X    = int(x)
  fractional_X = x - integer_X

  v1 = SmoothedNoise1(integer_X)
  v2 = SmoothedNoise1(integer_X + 1)

  return Interpolate(v1 , v2 , fractional_X)

end function

इस फ़ंक्शन को पूर्णांक अवधि के साथ समय-समय पर संशोधित करने के लिए तुच्छ रूप से संशोधित किया जा सकता है। बस एक पंक्ति जोड़ें:

integer_X = integer_X % Period

गणना करने से पहले v1और v2। इस तरह, पूर्णांक निर्देशांक के मान हर अवधि इकाइयों को दोहराएंगे, और प्रक्षेप यह सुनिश्चित करेगा कि परिणामी फ़ंक्शन सुचारू हो।

ध्यान दें, हालांकि, यह केवल तभी काम करता है जब पीरियड 1 से अधिक हो। इसलिए, वास्तव में सीमलेस टेक्सचर बनाने में इसका उपयोग करने के लिए, आपको पीरियड x पीरियड स्क्वायर का नमूना लेना होगा, न कि 1x1 का।

Comments

लेकिन आप noise2आवधिक कैसे बनाते हैं (एक छोटी अवधि जैसे कि 1 इकाई)? मुझे लगता है कि आखिरकार यह सवाल क्या है। मानक पेर्लिन शोर प्रत्येक अक्ष पर 256 की अवधि के साथ आवधिक है, लेकिन आप एक छोटी अवधि के साथ एक संशोधित शोर चाहते हैं।

— नाथन रीड

@Nathan रीड यदि आप फोन noise2के रूप में सुझाव दिया, तुम जाएगा , समय-समय पर परिणाम प्राप्त है कि क्या समारोह अपने आप में समय-समय पर है या नहीं। क्योंकि तर्क हर 1 इकाई के आसपास लिपटे रहते हैं।

— बात नहीं

लेकिन फिर आपको ग्रिड लाइनों पर सीम मिलते हैं, है न? चूंकि इस बात की कोई गारंटी नहीं है कि शोर 2 (0, 0.999) कुछ भी शोर 2 (0, 0) के पास है, जब तक कि मैंने कुछ याद नहीं किया है।

— नाथन रीड

@ नथन रीड यह एक अच्छी बात है। वास्तव में, मैंने अपने पुराने कोड की फिर से जाँच की और यह पता चला कि मैं गलत था। मैं अब उत्तर को संपादित करूँगा।

— नहीं

महान! यह वास्तव में अब एक अच्छा जवाब है। +1 :)

— नाथन रीड

Answer 6

एक अन्य विकल्प यह है कि कामेच्छा पुस्तकालयों का उपयोग करके शोर उत्पन्न किया जाए। आप अंतरिक्ष की एक सैद्धांतिक अनंत राशि पर मूल रूप से शोर उत्पन्न कर सकते हैं।

निम्नलिखित पर एक नज़र डालें: http://libnoise.sourceforge.net/tutorials/tutorial3.html#tile

उपरोक्त में से एक एक्सएनए पोर्ट भी है: http://bigblackblock.com/tools/libnoisexna

यदि आप XNA पोर्ट का उपयोग करते हैं, तो आप कुछ इस तरह से कर सकते हैं:

Perlin perlin = new Perlin();
perlin.Frequency = 0.5f;                //height
perlin.Lacunarity = 2f;                 //frequency increase between octaves
perlin.OctaveCount = 5;                 //Number of passes
perlin.Persistence = 0.45f;             //
perlin.Quality = QualityMode.High;
perlin.Seed = 8;

//Create our 2d map
Noise2D _map = new Noise2D(CHUNKSIZE_WIDTH, CHUNKSIZE_HEIGHT, perlin);

//Get a section
_map.GeneratePlanar(left, right, top, down);

GeneratePlanar प्रत्येक दिशा में वर्गों को प्राप्त करने के लिए कॉल करने का कार्य है जो बाकी बनावटों के साथ मूल रूप से जुड़ जाएगा।

बेशक, यह विधि एक एकल बनावट होने की तुलना में अधिक महंगा है जो कि कई सतहों पर उपयोग की जा सकती है। यदि आप कुछ रैंडम टिलिबल टेक्सचर बनाना चाहते हैं, तो यह कुछ ऐसा हो सकता है जो आपको रुचिकर लगे।

Answer 7

हालांकि यहां कुछ जवाब हैं जो काम करेंगे, उनमें से अधिकांश जटिल, धीमी और समस्याग्रस्त हैं।

तुम सब करने की ज़रूरत है एक आवधिक शोर पीढ़ी समारोह का उपयोग करें । बस!

पेर्लिन के "उन्नत" शोर एल्गोरिथ्म पर आधारित एक उत्कृष्ट सार्वजनिक डोमेन कार्यान्वयन यहां पाया जा सकता है । आप की जरूरत समारोह pnoise2 है। कोड स्टीफन गुस्तावसन द्वारा लिखा गया था, जिन्होंने इस मुद्दे के बारे में यहां एक स्पष्ट टिप्पणी की है , और दूसरों ने गलत दृष्टिकोण कैसे लिया है। गुस्तावसन को सुनें, वह जानता है कि वह किस बारे में बात कर रहा है।

विभिन्न गोलाकार अनुमानों के बारे में यहां कुछ ने सुझाव दिया है: ठीक है, वे सार काम (धीरे) में करते हैं, लेकिन वे एक 2 डी बनावट का उत्पादन भी करते हैं जो एक चपटा गोला है, ताकि किनारों को अधिक संघनित किया जाए, संभावना है कि एक अवांछित प्रभाव पैदा कर सकता है। बेशक, यदि आप अपनी 2 डी बनावट को एक गोले पर पेश करने का इरादा रखते हैं , तो यह रास्ता है, लेकिन यह वह नहीं है जो पूछा जा रहा था।

Answer 8

यहाँ पर शोर करने के लिए बहुत आसान तरीका है:

आप शोर के प्रत्येक पैमाने के लिए चारों ओर एक मॉड्यूलर लपेट का उपयोग करते हैं। ये क्षेत्र के किनारों को फिट करते हैं चाहे आप किस आवृत्ति पैमाने का उपयोग करें। तो आपको केवल सामान्य 2 डी शोर का उपयोग करना होगा जो बहुत तेज है। यहाँ लाइव वेबजीएल कोड है जो ShaderToy पर पाया जा सकता है: https://www.shadertoy.com/view/4dlGW2

शीर्ष तीन कार्य सभी कार्य करते हैं, और fBM को 0.0 से 1.0 सीमा में एक वेक्टर x / y पास किया जाता है।

// Tileable noise, for creating useful textures. By David Hoskins, Sept. 2013.
// It can be extrapolated to other types of randomised texture.

#define SHOW_TILING
#define TILES 2.0

//----------------------------------------------------------------------------------------
float Hash(in vec2 p, in float scale)
{
    // This is tiling part, adjusts with the scale...
    p = mod(p, scale);
    return fract(sin(dot(p, vec2(35.6898, 24.3563))) * 353753.373453);
}

//----------------------------------------------------------------------------------------
float Noise(in vec2 x, in float scale )
{
    x *= scale;

    vec2 p = floor(x);
    vec2 f = fract(x);
    f = f*f*(3.0-2.0*f);
    //f = (1.0-cos(f*3.1415927)) * .5;
    float res = mix(mix(Hash(p,                  scale),
        Hash(p + vec2(1.0, 0.0), scale), f.x),
        mix(Hash(p + vec2(0.0, 1.0), scale),
        Hash(p + vec2(1.0, 1.0), scale), f.x), f.y);
    return res;
}

//----------------------------------------------------------------------------------------
float fBm(in vec2 p)
{
    float f = 0.4;
    // Change starting scale to any integer value...
    float scale = 14.0;
    float amp = 0.55;
    for (int i = 0; i < 8; i++)
    {
        f += Noise(p, scale) * amp;
        amp *= -.65;
        // Scale must be multiplied by an integer value...
        scale *= 2.0;
    }
    return f;
}

//----------------------------------------------------------------------------------------
void main(void)
{
    vec2 uv = gl_FragCoord.xy / iResolution.xy;

#ifdef SHOW_TILING
    uv *= TILES;
#endif

    // Do the noise cloud (fractal Brownian motion)
    float bri = fBm(uv);

    bri = min(bri * bri, 1.0); // ...cranked up the contrast for no reason.
    vec3 col = vec3(bri);

#ifdef SHOW_TILING
    vec2 pixel = (TILES / iResolution.xy);
    // Flash borders...
    if (uv.x > pixel.x && uv.y > pixel.y                                        // Not first pixel
    && (fract(uv.x) < pixel.x || fract(uv.y) < pixel.y) // Is it on a border?
    && mod(iGlobalTime-2.0, 4.0) < 2.0)                 // Flash every 2 seconds
    {
        col = vec3(1.0, 1.0, 0.0);
    }
#endif
    gl_FragColor = vec4(col,1.0);
}

Comments

आपकी छवि लिंक मृत हो गई। मैंने एक सर्वश्रेष्ठ अनुमान लिया और इसे आपके द्वारा पोस्ट किए गए shadertoy कोड से आउटपुट के स्क्रीन शॉट के साथ बदल दिया। यदि यह सही नहीं है, तो कृपया अपनी इच्छित छवि को सीधे स्टैक एक्सचेंज सर्वर पर अपलोड करें।

— Pikalek

Answer 9

मेरे पास टाइल के किनारों (किनारे से लिपटे) के पास कुछ खराब-बुरे परिणाम नहीं थे , लेकिन यह इस बात पर निर्भर करता है कि आप किस प्रभाव को प्राप्त करने की कोशिश कर रहे हैं और सटीक शोर पैरामीटर। कुछ हद तक धुंधले शोर के लिए महान काम करता है, स्पाइक / ठीक-दाने वाले के साथ इतना अच्छा नहीं है।

Answer 10

मैं इसी तरह के मुद्दे के जवाब की तलाश में इस धागे की जांच कर रहा था, तब मुझे इस अजगर कोड के डेवलपर से एक साफ और कॉम्पैक्ट समाधान मिला , जिससे पेर्लिन / सिम्प्लेक्स शोर से फ्रैक्टल शोर उत्पन्न होता था। अपडेट किया गया कोड इस (बंद) अंक में प्रदान किया गया है और बाईं ओर (और ऊपर और नीचे के लिए समान) के बराबर "जनरेटर" के दाईं ओर के ग्रेडिएंट्स को सेट करने के लिए फिर से शुरू किया जा सकता है, जैसे कि

# Gradients
angles = 2*np.pi*np.random.rand(res[0]+1, res[1]+1)
gradients = np.dstack((np.cos(angles), np.sin(angles)))
# Make the noise tileable
gradients[-1,:] = gradients[0,:]
gradients[:,-1] = gradients[:,0]

एक सुरुचिपूर्ण और स्वच्छ समाधान की तरह लगता है, मैं पूरे कोड को यहां कॉपी करने से बचता हूं (क्योंकि यह मेरा अपना समाधान नहीं है), लेकिन यह ऊपर दिए गए लिंक पर उपलब्ध है। आशा है कि यह किसी के लिए एक तिलिस्मीय भग्न 2d छवि का निर्माण करने के लिए उपयोगी हो सकता है जैसे कि मुझे ज़रूरत थी, कलाकृतियों या विकृतियों से मुक्त।