Screen Space Distortion for FX using render to texture

BluePrintRandom · August 15, 2016, 11:07am

setup
Camera 1 = aimed at plane

plane = video texture of camera 2 and also is distorted using kd tree to find points in radius

Camera 2 =aimed at main scene

when ‘Exposion’ happens in main scene, get screen position, use screen position to get screen vect in main camera, use to cast rays at plane, to use kd tree to put points on effect list, as well as set position.

Points are added to list [‘FX’] and is used with property ‘Run’ to run the script until all vertex are back to normal position.

Attachments

ScreenSpaceDistortion.blend (711 KB)

Thatimster · August 15, 2016, 3:44pm

Can you change the warp direction? I think having a swelling effect would look better for an explosion rather than pulling the texture inwards.

BluePrintRandom · August 15, 2016, 4:14pm

I am afk at the moment but I think scaling the plane to -1 on z will be a quick fix,

I will try and write it to do both later, and maybe a ripple wave,

edit: negative scale on screen +flip normals seems good. (have not checked to make sure orientations are correct) I will try and get to tinkering tonight*

Nicholas_A · August 17, 2016, 8:11am

I’m afk as well but is this in python or is it a shader

BluePrintRandom · August 17, 2016, 8:43am

python

I use render to texture on a plane, and use a KDtree to distort the screen,

Nicholas_A · August 18, 2016, 1:13pm

Wait whats kd tree. Sorry if its a dumb question

BluePrintRandom · August 18, 2016, 1:35pm

mensional space. k-d trees are a useful data structure for several applications, such as searches involving a multidimensional search key (e.g. range searches and nearest neighbor searches). [I]k-d trees are a special case of binary space partitioning trees.)

Imagine building a list of all vertex that are in a radius, or finding the closest point, in python with a loop

[/I]https://www.blender.org/api/blender_python_api_2_72_0/mathutils.kdtree.html

for mesh in object.meshes:
    diff = ray.hitPoint-own.worldPosition
    localpoint = own.worldOrientation.inverted()*diff
    selectList =[]
    for m_index in range(len(mesh.materials)):
      for v_index in range(mesh.getVertexArrayLength(m_index)):
         vertex = mesh.getVertex(m_index, v_index)
         diffVect = vertex.XYZ-localpoint
         distance = diffVect.magnitude
         if distance &lt; radius:
             selectList.append([vertex,v_index])

this is much slower than calling the kdtree that you build on frame zero, and then checking using that
(itterating using C, and also using an algorithm that does not traverse the whole point list*)

so it’s much faster, the more data there is to sort through that pertains to 3d space.

you can use a ‘worldKDTRee’ for LOD and physics LOD and Lamp LOD etc.
so long as the points are static that you are operating on (no need to rebalance the tree*)

in this example I build the tree with




#build kd tree


if 'KD' not in own:
    own['FX']=[]
    VLIST =[]
    for mesh in own.meshes:
        for m_index in range(len(mesh.materials)):
            for v_index in range(mesh.getVertexArrayLength(m_index)):
                vertex = mesh.getVertex(m_index, v_index)
                VLIST.append([vertex,vertex.XYZ])
    size = len(VLIST)
    kd = mathutils.kdtree.KDTree(size)
    index =0
    for Vert in VLIST:
        kd.insert(VLIST[index][1], index)
        index+=1


    kd.balance()


    
    own['KD']=kd
    own['VLIST']=VLIST

later any object can call that tree with target[‘KD’]
(so a vector can than be used with all these commands to access the data)

co = a vector
(like a ray hitPoint or a mouseOver hitPostion or a collision callback contact point location)

in this instance - I localize a point to the object that we then check using the local as the CO in the KDTree command

guramarx · August 18, 2016, 9:24pm

@BluePrintRandom
That’s very good use of the kdtree with the texture module, thanks

btw since you already know the object only have 1 mesh and 1 material you can extract the vertex faster by avoiding expensive function calls or attribute look up from inside the nested loops and better yet the loops

eg.


mesh = own.meshes[0]
mat_index = 0
vert_len = mesh.getVertexArrayLength(mat_index)
VLIST = [mesh.getVertex(mat_index, v_index) for v_index in range(vert_len)]

kangpaper · September 23, 2016, 9:06pm

Great as usual, however the sudden FPS drop when monster is near is frustrating. Wait for a solution