Hi all

I've been playing with procedural entropy again, inspired by a visit to a
medieval castle over the summer. This is a good waypoint in the project; the
environment is a bit old-school but I'm pretty happy with the castle.

It occurred to me that an 'easy' way to ruin brick structures is to construct
geometry to define the missing areas and use a simple inside test when placing
bricks. This is slightly complicated by the need to perform the exclusion test
on a brick's final position, so I ended up writing macros to fill some simple
regions with bricks. The castle here was made using just two top-level macros -
filled boxes and hollow cylinders with arbitrary position/orientation.

A further issue was that the exclusion geometry was too regular, giving neat
pixellated edges to all the removed areas. So instead of using the geometry
directly, bricks are placed or omitted according to a pigment function defined
by a turbulated object pattern.

Windows and doors, plus their arches and frames, were achieved using the same
basic tools, albeit without turbulence on the exclusion shape, and can therefore
be ruined by the same process.

Not sure where to go with it next...!

Bill

Post a reply to this message

Attachments:
Download 'castle1.jpg' (216 KB)

Preview of image 'castle1.jpg'

On 10/3/21 1:07 PM, Bill Pragnell wrote:
> Hi all
> 
> I've been playing with procedural entropy again, inspired by a visit to a
> medieval castle over the summer. This is a good waypoint in the project; the
> environment is a bit old-school but I'm pretty happy with the castle.
> 
> It occurred to me that an 'easy' way to ruin brick structures is to construct
> geometry to define the missing areas and use a simple inside test when placing
> bricks. This is slightly complicated by the need to perform the exclusion test
> on a brick's final position, so I ended up writing macros to fill some simple
> regions with bricks. The castle here was made using just two top-level macros -
> filled boxes and hollow cylinders with arbitrary position/orientation.
> 
> A further issue was that the exclusion geometry was too regular, giving neat
> pixellated edges to all the removed areas. So instead of using the geometry
> directly, bricks are placed or omitted according to a pigment function defined
> by a turbulated object pattern.
> 
> Windows and doors, plus their arches and frames, were achieved using the same
> basic tools, albeit without turbulence on the exclusion shape, and can therefore
> be ruined by the same process.
> 
> Not sure where to go with it next...!
> 
> Bill
>

Cool. When I was warping isosurface mazes, I thought about introducing 
localized entropy / randomness to the maze walls. Perhaps adding - near 
locations of erosion - debris. I never got anywhere with it.

On turbulence, a thought I've had is it might be useful to have a 
generic black hole warp like mechanism (shape defined intensity control) 
to locally fade turbulence in an out. Something more controllable than 
applying turbulence to the whole pattern(1).

Bill P.

(1) - This is doable with functions, but not all that easy to set up.

Post a reply to this message

Op 03/10/2021 om 19:07 schreef Bill Pragnell:
> Hi all
> 
> I've been playing with procedural entropy again, inspired by a visit to a
> medieval castle over the summer. This is a good waypoint in the project; the
> environment is a bit old-school but I'm pretty happy with the castle.
> 
> It occurred to me that an 'easy' way to ruin brick structures is to construct
> geometry to define the missing areas and use a simple inside test when placing
> bricks. This is slightly complicated by the need to perform the exclusion test
> on a brick's final position, so I ended up writing macros to fill some simple
> regions with bricks. The castle here was made using just two top-level macros -
> filled boxes and hollow cylinders with arbitrary position/orientation.
> 
> A further issue was that the exclusion geometry was too regular, giving neat
> pixellated edges to all the removed areas. So instead of using the geometry
> directly, bricks are placed or omitted according to a pigment function defined
> by a turbulated object pattern.
> 
> Windows and doors, plus their arches and frames, were achieved using the same
> basic tools, albeit without turbulence on the exclusion shape, and can therefore
> be ruined by the same process.
> 
> Not sure where to go with it next...!
> 
> Bill
> 

Smart! Very believable and interesting result indeed. You might want to 
try using different sized stones instead of bricks for a change, or in 
addition to bricks. And maybe make the arches and window frames out of 
stone instead of bricks. They would react differently to decay.

-- 
Thomas

Post a reply to this message

hi,

"Bill Pragnell" <bil### [at] hotmailcom> wrote:
> Hi all
>
> I've been playing with procedural entropy again, inspired by a visit to a
> medieval castle over the summer. ...

v nice, would have liked more resolution to see the "crumbled" wall edge(s)
better.


> Not sure where to go with it next...!

time-lapse "movie", a frame every 50 years?  :-)


regards, jr.

Post a reply to this message

William F Pokorny <ano### [at] anonymousorg> wrote:
> On turbulence, a thought I've had is it might be useful to have a
> generic black hole warp like mechanism (shape defined intensity control)
> to locally fade turbulence in an out. Something more controllable than
> applying turbulence to the whole pattern(1).

Yes this would be useful.

> (1) - This is doable with functions, but not all that easy to set up.

I can't immediately see how to do that, but I'll take your word for it!

Bill

Post a reply to this message

Thomas de Groot <tho### [at] degrootorg> wrote:
> You might want to
> try using different sized stones instead of bricks for a change, or in
> addition to bricks. And maybe make the arches and window frames out of
> stone instead of bricks. They would react differently to decay.

Filling space with irregularly-shaped bricks or stones is a non-trivial problem,
one I've often thought about but never seriously attempted! However, discrete
layers of different brick sizes would be feasible without effort (if
architecturally realistic!).

Arches and window frames made more carefully from larger custom components would
be my next step I think. More open structures like cloisters or church-style
windows would look great as ruins.

Bill

Post a reply to this message

"jr" <cre### [at] gmailcom> wrote:
> v nice, would have liked more resolution to see the "crumbled" wall edge(s)
> better.

Ha, unfortunately the closer you get the less realistic it looks! There's no
mortar, and no real variation in brick shape. There's a reason I made the bricks
small, the scene large, and the camera wide-angle!

> time-lapse "movie", a frame every 50 years?  :-)

At the rate I work in POV-Ray, that sounds about right :)

Bill

Post a reply to this message

"Bill Pragnell" <bil### [at] hotmailcom> wrote:
> Hi all
>
> I've been playing with procedural entropy again, inspired by a visit to a
> medieval castle over the summer.

Looks good, Bill! The parse time must have been pretty high, but maybe not.

> Not sure where to go with it next...!

I'm interested to see where you take it.

Sam

Post a reply to this message

"Bill Pragnell" <bil### [at] hotmailcom> wrote:
> William F Pokorny <ano### [at] anonymousorg> wrote:
> > On turbulence, a thought I've had is it might be useful to have a
> > generic black hole warp like mechanism (shape defined intensity control)
> > to locally fade turbulence in an out. Something more controllable than
> > applying turbulence to the whole pattern(1).
>
> Yes this would be useful.
>
> > (1) - This is doable with functions, but not all that easy to set up.
>
> I can't immediately see how to do that, but I'll take your word for it!
>
> Bill

I did that with the spiral / vortex warp.  You interpolate between the max
radius of the effect being zero to the center being 1, and use that as a
strength multiplier for the turbulence function.

Post a reply to this message

"Bill Pragnell" <bil### [at] hotmailcom> wrote:

> Filling space with irregularly-shaped bricks or stones is a non-trivial problem,
> one I've often thought about but never seriously attempted! However, discrete
> layers of different brick sizes would be feasible without effort (if
> architecturally realistic!).

I think that trying to fit existing stones into a wall is the REALLY hard part,
but I think there has to be:

1. a way to make a pseudo-mathematical texture like crackle/Voronoi

2. a way to generate pieces to fit into a given empty space.
Maybe a way to loop through y values and combine that with a crossing number
algorithm to find the edges of the already filled space as a place to start
making a new block.

Maybe add each new block to a union {} in an inc file written to for each frame
of an animation.  Then the crossing number gets calculated for a horizontal line
at the present y-value and the whole union of blocks....

Not saying this is "simple", just less complex than some of the other things
we've discussed here in the past.

Post a reply to this message