Procedural Ice Path Formation System Houdini Tutorial

hi everyone welcome to the channel today we are going to create a fully procedural ice platformation effect inside Houdini we're going to use a couple of really cool techniques to achieve a fully scalable system that we can easily adjust to their production needs so let's actually take a look at what we are going to be creating [Music] alright so let's create a new geometry and here we need two points so let's use the add nodes we can make a copy and the first we can call it the source and the second will be the target and here let's at one point and here the second one but let's change the Z position to maybe five for now and so let's zoom out so you can see the one is here and the second is at the center so now we can draw a per angle and let's connect the source to the second to the first input and the target the second one let's display the wrangle and now let's press alt e to bring this window for vex code because we're going to type quite much of it so yeah maybe let's let's keep it like that and yeah let's start so first we need a vector let's call it Target pose and here we want to store the position of our of our Target that we already created so let's use a Point function and we're going to take attribute from first input we're in position of point zero like this and now let's create another vector which will be Vector to Target from from source so let's call it to Target and let's subtract Target position vlp like this now we can go next and we can make a direction from this Vector so another vector Direction two Target and let's make it equal to normalize normalized Vector that we already created above so to Target okay so next we need at this task so float distance to Target and we need to calculate the length of the two target vector like this and yeah we can preview the normal how it looks like via 10 equals there are two target let's hit apply and let's prove it normal so we can see that this is our resource point and here if you display this is our Target so now the basically the direction to Target stores this direction that you can see that is previewed on normal so let's proceed and now let's create a new float let's call it duration and let's use a channel parameter integer and let's call it simply duration and with this parameter we will be manipulating like how long does it take for the path to to reach the the target Point basically so let's go and create a second float called controller offset and let's use a fit function and we're going to feed frame that will go from one to duration and we want to map this to go from value of 0 to 1. and then we're going to create a controller so Vector controller equals into Intel interpolate between position of the source and Target position and as an interpolator we are going to use the controller offset like this and yeah now let's specify the resolution of our path something like the base resolution how many basic steps we want to have for for for the main path so to do this we need to create an integer variable let's call it steps total and let's create another Channel parameter for it and let's call it let's call it steps total and next let's create another integer called cold steps steps maybe maybe step step scatter scatter like this and another Channel steps cutter we're going to use this variable to you know scatter some points for every step so this way we'll have like nicely procedurally generated distribution of the points along the path so you'll see later how it works actually and to to mix this we need a step offset variable and let's divide the distance to Target by steps total so this way we can calculate how how we can basically calculate the distance between each step by doing this and yeah so now let's now we only have these two points yeah we have source and the target so we need to populate the path we need to construct the path between the the source and the target so we need to create a for Loop let's start counting from zero and how many we want to we want basically as much points as there is a steps yes yeah we need to we have scatter um yeah we need to after scatter we need to create another variable let's call it steps steps current and let's convert to integer steps total times controller offset like this so we will be able to dynamically construct the path from as many points as we need at the current controller offset position so here let's specify a condition if I is less than steps current like this and let's increment by one after every Loop and here let's create a new vector position via p Plus iteration times multiplied by um multiplied by direction to Target and let's multiply it with step offset like this and next let's create a another vector called Next pose this is interesting because we are going to use this to like to calculate uh what is the next what is that what is the position of the next point after this iteration this will help us a lot so V at p Plus I plus 1 like this and now we can multiply it by uh like this we can copy and paste here so basically we're doing the same but for the for the for the next iteration and let's create uh integer variable called path PT and inside this we are going to store the reference to the point that we are going to create so at Point zero we want to create this add position like this and let's hit apply we have some arrows arrows steps total and steps current [Music] um yeah here is the problem and of course we haven't created the channels like this so we have a small type of here it should be controller spelled properly now if you click apply you don't have an error and if you go here to the parameters let's say for duration we want to have like 48 for example and four steps total maybe 15 and steps cutter like five steps cutter won't do anything for now anyway and let's let's see why it doesn't work because we should see some points here so another type of here it shouldn't be framer it should be framed like this so let's apply and now you can see how it works so basically you create the path dynamically based on this duration parameter it specifies how many frames does it take to to construct the path that goes from the source to the Target so if you do like 12 it will be really fast and so on so I will leave it at 48 for now and yeah let's proceed with to work with on the on the scattering actually because we have the like the main path for now and we want to make it more interesting and more more give it more Randomness so let's make a space here and for for that we need another loop so we need to Nest the loop inside loop so let's call the counter J equals zero and the condition will be if J is less than step scatter and let's increase by one like this and here we need another float called uh normalized Loop index and this will store like the all the loops but this value will be mapped to go from zero to one so let's use a fit function we're going to fit the J uh and it goes from 0 to step scatter minus one here and we want to map this as I said to go from zero to one like this after this let's create another float let's call it side random and let's round the number of randomly generated float like this and then let's fit this value site random equals let's use fit01 because it goes from zero to one and we want to fade fit itself to go from -1 to 1 like this and now let's create the vector called side direction we are going to use this variable to control you know how on on which side we want to push the scattered Point some will go you know to the to the left some will go to the right and that's why we calculated this random values here this will be like the the dictator for that so let's use a cross function and let's construct the vector here zero for the X component side random for the Y component and 0 for the Z and another Vector will be Direction to Target like this okay let's make a space here and now let's create the next Vector called offset Direction and let's it let's make it equal to psi side direction for now under float scatter range and for scatter range we're going to create Channel parameters so let's call it simply scatter [Music] range with this value we will be controlling how much point we want to scatter per every step Point here so it's it will be similar to resolution of the of the details of the scatters of the for the path so that's how it works next we need a vector called enable offset we're going to call uh we are going to call the scattered points the neighbors and the the main will be like the the steps so something like that let's make it able to offset Direction multiplied by scatter or neighbor offset yeah offset Direction Let's multiply it by scatter range like this but before let's maybe go to the scatter range and let's let's also multiply it with uh fit at random values of it let's use 501 and we want to fit uh random value generated from J multiplied by I and we want to fit it to go from 0.01 to one for now uh okay we have neighbor offset and after neighbor offset let's create new float called next pose lerp like this we're going to LARP you know we are going to scatter some points let's say we want to scatter some group here and we're going to use this value volume Xpose LARP to uh you know to smoothly distribute scattered points between the current point and the next one so float next pose LARP let's make it equal to random value generated from J multiplied by I and let's multiply it by Channel float let's call it smooth distribution Maybe like this and another vector neighbor pose this will be the position of our neighbor we are going to interpolate between position of the step point Next Step position and we are going to use next pose learn value as an interpolator like this and to that we want to add the offset so neighbor offset okay so now we can go ahead and let's create the vector neighbor to Target and let's make it equal to Target pose minus neighbor position like this okay so we have it now let's make a distance so float neighbor this to Target and we're going to calculate simply the length of this neighbor to Target like this okay and now let's create a normalized distance so float and distance to Target equals fit we're going to fit neighbor this to Target that goes from 0 to distance to Target and we're going to map it to go from 0 to 1. okay we have it now let's create a update the name neighbor pose variable so neighbor pose equals uh yeah we want to actually subtract so minus equals neighbor offset and let's multiply it by this normalized distance that we created so and this um to Target like this okay so we have this now let's make some space here and let's create another vector let's call it neighbor 2 controller Maybe this will be the vector between neighbor and controller so we have some scattered points here and we have also our controller you know controller is the the main interpolator you know that's drive that is driven by the frames that I already showed you so neighbor to controller let's make it equal to neighbor pose minus controller and here we need another float let's call it neighbor distance to controller so we need to calculate the length of this vector we can copy and paste and after this what do we need we have this we have that we need another float float let me think uh yeah let's let's create an influence range so float we're going to call call it controller influence range for example and let's make another Channel and let's call it controller influence range so with this value we'll be able to control um some other values like the spread of of the lines and so on based on the distance the current point is from the controller like this so we have this and now let's make a normalized value flow from this so float normalized influence range let's make it equal to fitted value of neighbor distance to controller that goes from 0 to controller influence uh range and let's Rim up this value to go from one to zero so it's kind of inversed and here we are now let's make some space here let's create another float Main Direction interpolator so we're going to interpolate the direction of the of the line based on on this value so we need to fit the uh basically inversed normalized distance to Target so we need to use an absolute function and here we need to subtract the and distance from the one so and distance to Target like this and we want to map this to go from 0.35 to maybe 0.1 or maybe 0.75 like this and here another vector neighbor Direction so it's actually we're getting close to it so normalized we need to normalize the interpolated Vector between the up Vector and direction to Target so um let's use a LARP function and we're going to learn between the up Vector so 0 1 0 and direction to the direction to Target and we're going to use let me think uh yeah we're going to use a main Direction interpolator like this so let's create another variable let's call it melt lerp delay we're going to create something like melt simulation something like that it's not not physically mailed I just called it in code like this it's basically like the rotation of the lines during the creation we are going to slightly rotate them to the ground like some kind of gravity and so let's use a fit function and we're going to fit a randomly generated number let's Maybe multiply I with j and let's add some random value like 2 maybe like this and let's fit this value to go from 1 to 1.1 so it's a small window but it will do the job you'll see and let's multiply it by duration actually duration like this so we have melt LARP delay now we need the layer itself so float meld lerp equals fit we're going to fit the frame to go from one to melt lerp delay and we want to normalize values to zero to one like this so now let's calcul let's create a a parameter for maximum rotation so we can easily control that so float rotation Max let's make it equal to float Channel called uh rotation Max like this now let's multiply it by let's multiply it by we have it here side there so uh side Direction inversed actually so this is what I was talking about previously some of the lines thanks to this randomization will be able to you know rotate towards this direction and some will go to this direction so let's go ahead and let's create a rotation actually so throw float wrote and let's convert to radians uh let's convert wrote Max and let me think yeah root Max multiplied by um normalized Loop index and this let's multiply this by melt lerb actually like this okay and now let's update the rotation so rotation multiplied by equals uh we're going to multiply by by inverse normalized distance to Target so 1 minus and this to Target and this to Target and now we need to create the uh Vector 4 variable so Vector 4 neighbor quotation because we are going to create a quaternion and let's use a quaternal function and here let's use a rotation that we already created and direction to Target as the axis for our rotation so now we can actually rotate our neighbor Direction so let's update neighbor Direction so let's use a q rotate function and we are going to uh use neighbor Q as a rotator and what do we want to rotate we want to rotate the neighbor Direction itself so neighbor Direction like this okay so we really we are really close to the end so let's make some space here and let's make another variable called hate Max with this value we'll be able to control the height of the lines actually so with some Randomness so let's actually implement this so we need another another channel for that let's call it uh faith Max and let's create another variable called hate and we're going to use a again feed 0 1 function to fit the value of uh randomly generated random randomly generated number like random Maybe J plus four maybe multiplied by I like this and let's map this to go from 0.1 to 8 Max and after this let's multiply it by inverse normalize this to Target so absolute value of 1 minus and this two Target this should be minus actually yep and here let's update the head so hey multiply by equals again we can yeah let's make the inverse of let me think normalized influence range so absolute one minus and influence range like this okay and next we want to um to actually finally calculate the the end of the line the the final position of each line so we are going to call it a tip pose and this will equal to 8th multiplied by neighbor Direction and we're going to add this to neighbor position like this so we have the position now we can go ahead and we can create finally the points so integer base equals add point zero neighbor position like this and another point for the top so integer top at point zero and let's use the tip pose like this and finally we can connect these two points with the line so add Prim zero polyline base we want to connect the base with the top like this okay so now let's click apply let's see if we have some errors yeah of course so it actually looks like I skipped the equal size on some variables assignments so here for and loop index and uh I can see it here too neighbor dur and mainder interpolator let's see another issues 45.93 we have another typo in neighbor Direction calculation so I forgot to close the braces for LARP function so we need to add this and another is just 47 and I also forgot to make an equal sign for melt lab delay variable we have another typo in melt lerp fit function so after one we need a comma and if we apply this now we need to go a little up and here controller influence range we need a small letter like this and after these changes it should work actually so we can take this back for now and let's actually create the parameters for our Channel functions right here so um let's experiment with those values so you can see how how all of this works so duration steps total we already told about this one now we have step scatter so this will control how many points we have scattered per uh per every every point so um we want to make a bigger range like this so you can see that we are spreading the scattered points across this perpendicular line but together with this we also have this smooth distribution so we can learn between current and lurp steps so if we do this you can see how it works but what's this important let's increase the hive because that's that's the core point of this so some properties we already coded it's like we have this Progressive Hive uh level that goes up as well as the uh rotation rotation we need to set rotation so maybe let's set it to 90. and you can see that by manipulating this rotation value we are spreading them from the from the main path so another cool thing is that this is this this variable that we used uh this normalized influence range so thanks to that you can see that if you play this we have this smooth transition the smooth rotation so when the controller goes it also spreads those lines a little so you can really combine these values like maybe you can you can even make something bigger like 240 so you will see more of this like that and you can actually control the influence range by this parameter that we already created so this is cool because if you change this to maybe 1.5 you can see that you also have this growing effect and this is the this influence will also affect the rotation so you can see so we have like the base functionality for now we have something that we can build on top of so we can now proceed and uh you know create the the mesh from it actually and you will be able to always come back to this and change these values as well as some of the values that were already coded here because we don't have a channel operator for for everything so you can experiment with some values here and you can always change and see how this effect is the final outcome of of this base system so yeah okay so now let's go to later frames like here and actually we have only two points per line for now maybe let's increase the height to go like maybe 1.5 um like this and let's use a resample node on this to you know to add more resolution to this and maybe let's use the length of value of 0.05 maybe 0 25 and after this let's uh let's create some irregular irregularities for this so we are going to use a attribute noise for that and we want to apply the noise to position parameters so p and let's use a zero centered value and this is too much so maybe you know let's play it with the values but let's decrease the amplitude you know something small for now you can always change this but we don't want too much of it here because you can easily exaggerate that I think it's too much so something really subtle like this it's important to keep this in you know in in mind that after applying attribute noise you can also uh slightly move them away from the ground so don't apply too much of it because you haven't implemented any functionality for this but you can of course you can you can take the base point and you can uh you can always manipulate the influence of it but I will leave it like this for now so after attribute noise uh maybe actually before it let's create a Wrangle node and we want to slightly Bend these lines so after resample node we need something like a curve view attribute so let's uh let's check this box here and you can see that in Geometry spreadsheet now we have this attribute here that goes from zero to one respectively across along the line so let's actually use this to to bend these lines a little so let's update the crew review attribute effort curve U equals let's inverse it for now so absolute value of 1 minus effort curve U itself and [Music] now we are going the Z direction for it you know this is really important here because uh I won't be implementing any logic to go along with direction for now so if you want you can but I will like hard code it here so this basically depends on the on the direction that you specified your target uh position so for now it goes on the positive Z axis so I can update the Z position so V add P dot Z minus equals and here we are going to multiply curve U attribute three times so Ctrl C multiply by curview and multiply it by curview once again and then we want to subtract uh curve you multiplied by 0.5 like this so you can see actually you have a little band uh you can actually disable it if you if you don't like it it's it depends on on your on your needs and after that because we already inverted the code review attribute but uh we need the original value so effort curve U equals we are going to invert invert it again so Ctrl C Ctrl V like this and we are done here we can go to the next step so now let's uh organize it a little and here we can drop another Wrangle node after the mountain after the noise node and here let's again let's uh let's inverse the F curview attribute so we can copy and paste it and now we are going to fit this to go from below because we don't want to go this to for this to go from uh zero value we want something a little bigger so I thought curve uh we're going to clamp this value itself to go from 0.01 to 1 like this you know just to avoid the zero values on the on the line so uh now we can drop a poly wire node to actually add the volume to these lines and after this we can drop a normal and yeah and here in poly wire let's let's play with some settings the the values that work for me is actually 0.1 for wire radius and here we can actually use the attribute and you're going to take the scale from curve U attribute itself and other values that I've changed is like the divisions I've made 12. and I think I will leave it as it is you can use another values but I will I won't spend more time on it let's proceed to The Next Step which is we need to create a VDB from this so VDB from polygons and we are going to use distance yeah and voxel size may be you need to play with these values I will I will leave it at 0.01 for now and now maybe we can you know because you can it looks like this that you can jump between this note and changing the settings here for now because uh before you actually proceed with anything that's it's a good idea to actually have some some shape of it so you can play with these settings here and make something actually that that looks good so I will set some values here and I will be here in a minute now let's proceed and let's move this video a little so V to be smooth like this maybe maybe three iterations like so for now you know we we just want the basic shape for now we will focus on the details later so we have a smooth now we need to convert this to the polygons so VDB convert like this and we want to convert to polygons uh I will leave it as it is for now and but yeah now we can we can go ahead and we can create a new material so let's go to the material material palette here and let's drop a principal Shader and now let's jump to the let's jump to the material Network and here let's call this Shader ice and going back to the object we can assign this material here so let's use material node and let's apply this material here like this so we have a material and now you can you know make some previews of how it actually works I will make a quick Sketchbook to show you the idea so here you can see how it actually looks like um it is cool because you know you can easily go right here and you can change the duration of it and everything as I said before but for now we need to make some basic scene setup so let's create the the camera and I will choose I will choose the angle like like this maybe something like that and we also need some light so let's create a distance light distance light and you know here you have your camera so I want the distance light to go something like 90 degrees from the camera uh Direction so maybe maybe like this for now and we also want some environment light so let's drop another here and apart from that I think it will be cool to add some area light something like here so we will see some some lights you know scattering on the on the edges of the spikes so maybe like this maybe here maybe like this and we can add another area light to lead the object from the above a little like this now we need to go back to our setup and here we need to create some attributes to control our Shader our material so we need basically two or three properties and I think that first we're going to uh take basically the curvature so after the conversion let's drop a measure node and we are simply going to measure the curvature like this so you know we can we can apply different effects to those red areas and differentiate everything from the blue one so yeah we have the curvature let's connect it here and now now let's go to the attribute noise here and let's drop a Wrangle we are going to Simply extract the the end points of each line and how we can do that well because we you know we have this uh curve you attribute that goes from zero to us so we can delete everything except the one value so this will give us the only the top points so let's actually do that so we did an if condition if effort curve U is not equal to one we are going to remove everything remove point zero at Point number so if you preview the points you can see that these points are actually the the tips the tips the end points of each line so it's kind of cool we're going to use this to transform uh some attributes so let's uh let's add some color here and let's make it red what's really important here is in all those colors that we are going to set here to transfer these attributes use ful numbers whole numbers for each component so it's uh it's really you know important to not have like 0.5 or something like that you need a one in one component and zero for the other so then we can go here and we can actually do an attribute transfer attribute transfer and we can transfer this this color here but we can play with the conditions here okay so for distance threshold we can use a value of 0.0 Farm maybe and blend with something small maybe 0.0 8 or zero or five but let's drop a color for the main object so let's make it green zero one zero so we can see what's going on maybe uh yeah I think it's okay for now we will change it later so now we can create another attribute so um before the resample node let's drop another Wrangle node actually we need to create an add point so let's connect it to the first input and this will go to the second one and here we need to create this a point actually so let's click this plus and here basically we want to drive this point based on the position of the controller from this code and basically the controller doesn't exist physically anywhere here it's just the value that is controlling the interpolation between Source position and Target position so we need to extract it somehow and here you can see this is stored right here so the way we are going to do this is simply we're going to create an attribute called controller of type vector and let's assign the controller value to it like this and now we are going to grab this value here so V ATP equals we're going to get the controller attribute it may be from point zero so now if you preview the point you should you should see that the point is moving accordingly to to the controller that you set here so this duration that is controlling how the path actually grows you can see because you can change the duration to maybe 24 it will go faster and this point will also follow follow this movement so you can see the beginning is here and the point is here too so I will change this back to 48. but having this point we can now make another color transfer to uh you know to to control some another cool Shader effect so let's drop a color note here and we're going to make it and blue so zero zero one like this and now we can go down and we can create another attribute transfer and we are going to transfer from from the controller itself like this maybe go by let's go back to this and um let's change the source and destination to points and you know just to be accurate and let's deselect The Primitives and in points we only do only want to transfer the color so actually you can copy and paste this and get rid of that so we don't have to do it you know twice so we have this and now actually if you preview it it looks like this but let's go to the later frames you can already see that at the beginning at the front we can see that you already are transferring some colors so we can experiment with the values here so maybe I will use something like 0.25 and for Bland I don't know something like one point one maybe for now and we are going to use these colors actually to create a mask for the Shader itself so it won't look like this like we won't have a red green and blue and you know all these colors in our eyes we are going to separate these colors to create the zero to one values that will control our Shader so let's actually do that let's drop a wrinkle note here wrangle and inside the Wrangle Let's uh let's create a float and we're going to call this maybe controller mask for the mask that is you know driving this front part of the object so let's make it equal to V at CD we want to only get the blue color so it's the Z component and another mask will be um tip mask for the individual tips of the lines so we are going to take the red color so it will be X component like this so we have these two masks and we have also the curvature from from here so now we can drop a null node here and we can call it out for now and now we're ready to uh we're ready to jump to the material Network and experiment with everything [Music] [Music] [Music] foreign so let's take a look from the camera view and before that let's actually make some some good shape of it so I will leave controller I will leave the duration for now as it is and for steps total I will use the value of 100 as it is and Scatter range maybe I will use something like 0.25 and for smooth distribution I will leave it at one but step scatter I will scatter more of it so maybe 15. like this and controller influence will be one and rotation Max I will leave it at 120. like this so I like this but hey for the half I will I will double it so I will make it three maybe too much Maybe two okay and for VDB let's go here and yeah I can I can leave it at 0.01 so let's jump to the render View to see how it actually looks like and let's jump to the material Network so first we can turn off the use Point color here and we can start from importing our attributes so we need an bind node for that and first we're going to import the curvature itself so we have a curvature and if you connect this to surface base color you can see already how it affects the mesh so we can actually use this mask to mix between two colors so let's create a constant node and let's change this to color type and let's uh let's make it you know slightly blue but something really light like this and let's copy and paste here and this one will go to more greenish like this maybe but really really light values like this and now we can drop a mix node and we can simply mix between these two and use this value as an you know interpolator so you can see something like that we can I think we can go back to to the light and maybe change this light that is above to you know have maybe 0.4.5 intensity and environment light Maybe 0.52 like this and yeah I think it's good for now let's go back to the material and here we can we can also go and change the change the ior to maybe two and for roughness actually we can we can take this curvature and we can clamp it to go from 0.2 to 1 and we can connect this to to roughness actually so roughness roughness here roughness as well as we can use another clamp and maybe instead of one let's use 0.8 for the max value and we can connect this to transparency like this but maybe let's go back to the uh to our setup and let's actually change these values a little so here where we are transferring this I think we can go to the conditions and you know change it a little maybe something like that to have some bigger values to have more red basically maybe 0.8 yeah let's go to the camera and let's see how it actually looks like 0.2 Maybe okay I will leave it at 0.1 but uh yeah I think it's okay for now let's uh let's go back to the network okay now let's uh let's actually add another color for transmission so maybe something more bluish and now we can import this another attribute so we can copy this bind node paste it somewhere here maybe and it was called tip mask as well as the controller mask controller mask so now we can add them together here and we can we can use a clamp node and we can clamp it to go from 0.2 to 0.3 and we can use it to to control the emission intensity actually so we can go here and connect the emission intensity and now we also need an emission collar so let's uh let's actually copy this here nodes together with the mix let's paste it here but for the controller we are going to use the tip mask only so let's connect it to the bias and let's connect this mix node to emission color but let's actually change the colors a little maybe this and I don't know like this I've noticed that we are actually you know in my case I wasn't displaying the final note so the output was slightly different so now we can actually work on this so um maybe let's experiment with the emission color for now I think that there was too much too much green here so let's maybe change this to something more blue but a little lighter like this maybe and also this controller we can actually we can add a little more blend to the controller so let's go back to the object here and here in the transfer from controller we can increase this to maybe 1.5 or 1.85 so this bluish area is a little longer and maybe here we can experiment with this too maybe 0.05 yeah so we have more variation here in these areas I think it looks cool like this okay so let's back to the material and here I will only add basically I can copy the constant I will add the value for the for the code here and I will make it to for example and yeah this is the basic setup really basic and I will leave it to you for now you can experiment with this you can improve it I won't spend any more time on it but you can definitely add more features you know experiment with this at this point you can also go back to the object level to our setup and you can you know play with these settings to shape the object however you like you can for example change the steps cutter to maybe 45 to add more points to it and you can combine it with changing the Y radius to something smaller like 0.05 so you will have more details and yeah I think it's all from me so thanks for watching and see you again

Channel: Lusiongate

Views: 10,226

Keywords: Houdini, Houdini Tutorial, Houdini fx, vfx, houdini vfx, houdini procedural, houdini ice, houdini frost, vfx tutorial, ice vfx tutorial, houdini ice blast, houdini blast, houdini vex, game vfx, mantra ice

Id: wQWXb4vdTMM

Length: 68min 22sec (4102 seconds)

Published: Sun Apr 30 2023