From 388e80b02d5783e4068c413001840a8aca0d6393 Mon Sep 17 00:00:00 2001 From: aignacio_sf <> Date: Sat, 21 Oct 2006 02:05:46 +0000 Subject: [PATCH] Initial nurbs support. Sampled points are used as control points to create nurbs curves. --- direct/src/motiontrail/MotionTrail.py | 668 +++++++++++++++----------- 1 file changed, 388 insertions(+), 280 deletions(-) diff --git a/direct/src/motiontrail/MotionTrail.py b/direct/src/motiontrail/MotionTrail.py index a890543fb9..a678eece59 100644 --- a/direct/src/motiontrail/MotionTrail.py +++ b/direct/src/motiontrail/MotionTrail.py @@ -11,13 +11,13 @@ def remove_task ( ): if (total_motion_trails > 0): print "warning", total_motion_trails, "motion trails still exist when motion trail task is removed" - + MotionTrail.motion_trail_list = [ ] taskMgr.remove (MotionTrail.motion_trail_task_name) - + print "MotionTrail task removed" - + MotionTrail.task_added = False return @@ -32,12 +32,12 @@ class MotionTrailVertex: self.start_color = Vec4 (1.0, 1.0, 1.0, 1.0) self.end_color = Vec4 (0.0, 0.0, 0.0, 1.0) self.v = 0.0 - + class MotionTrailFrame: def __init__ (self, current_time, transform): self.time = current_time self.transform = transform - + class MotionTrail(NodePath, DirectObject): notify = directNotify.newCategory ("MotionTrail") @@ -62,13 +62,13 @@ class MotionTrail(NodePath, DirectObject): self.fade_end = False self.fade_start_time = 0.0 self.fade_color_scale = 1.0 - + self.total_vertices = 0 self.last_update_time = 0.0 self.texture = None self.vertex_list = [ ] self.frame_list = [ ] - + self.parent_node_path = parent_node_path self.previous_matrix = None @@ -88,39 +88,30 @@ class MotionTrail(NodePath, DirectObject): # node path states self.reparentTo (parent_node_path) - self.geom_node = GeomNode ("motion_trail") - self.geom_node_path = self.attachNewNode(self.geom_node) + self.geom_node = GeomNode ("motion_trail") + self.geom_node_path = self.attachNewNode(self.geom_node) node_path = self.geom_node_path ### set render states node_path.setTwoSided (True) - # additive blend states - node_path.setTransparency (True) - node_path.setDepthWrite (False) - node_path.node ( ).setAttrib (ColorBlendAttrib.make (ColorBlendAttrib.MAdd)) - - # do not light - node_path.setLightOff ( ) - - # disable writes to destination alpha, write out rgb colors only - node_path.setAttrib (ColorWriteAttrib.make (ColorWriteAttrib.CRed | ColorWriteAttrib.CGreen | ColorWriteAttrib.CBlue)); - - # do not display in reflections - OTPRender.renderReflection (False, self, 'motion_trail', None) - + # set additive blend effects + OTPRender.setAdditiveEffect (node_path, 'motion_trail') if (MotionTrail.task_added == False): # taskMgr.add (self.motion_trail_task, "motion_trail_task", priority = 50) taskMgr.add (self.motion_trail_task, MotionTrail.motion_trail_task_name) self.acceptOnce ("clientLogout", remove_task) - + MotionTrail.task_added = True - - + + self.relative_to_render = False + + self.use_nurbs = False + self.resolution_distance = 0.5 return @@ -128,14 +119,14 @@ class MotionTrail(NodePath, DirectObject): self.root_node_path = None self.parent_node_path = None self.removeNode() - + def print_matrix (self, matrix): separator = ' ' print matrix.getCell (0, 0), separator, matrix.getCell (0, 1), separator, matrix.getCell (0, 2), separator, matrix.getCell (0, 3) print matrix.getCell (1, 0), separator, matrix.getCell (1, 1), separator, matrix.getCell (1, 2), separator, matrix.getCell (1, 3) print matrix.getCell (2, 0), separator, matrix.getCell (2, 1), separator, matrix.getCell (2, 2), separator, matrix.getCell (2, 3) print matrix.getCell (3, 0), separator, matrix.getCell (3, 1), separator, matrix.getCell (3, 2), separator, matrix.getCell (3, 3) - + def motion_trail_task (self, task): current_time = task.time @@ -146,99 +137,19 @@ class MotionTrail(NodePath, DirectObject): while (index < total_motion_trails): motion_trail = MotionTrail.motion_trail_list [index] if (motion_trail.active and motion_trail.check_for_update (current_time)): - + transform = None - + if (motion_trail.root_node_path != None) and (motion_trail.root_node_path != render): motion_trail.root_node_path.update ( ) - - """ - transform = motion_trail.getNetTransform ( ).getMat ( ) - print "net matrix", transform.__repr__ ( ) - # transform = motion_trail.root_node_path.getTransform (motion_trail.parent_node_path).getMat ( ) - transform = motion_trail.parent_node_path.getTransform (motion_trail.root_node_path).getMat ( ) - print "rel matrix", transform.__repr__ ( ) - - transform = motion_trail.parent_node_path.getTransform (motion_trail).getMat ( ) - print "lll matrix", transform.__repr__ ( ) - """ - - """ -# transform = motion_trail.root_node_path.getTransform (motion_trail.parent_node_path).getMat ( ) - transform = motion_trail.parent_node_path.getTransform (motion_trail.root_node_path).getMat ( ) - print "rel matrix" - self.print_matrix (transform) - - if (motion_trail.root_node_path != None): - # motion_trail.parent_node_path - - # transform_state = motion_trail.parent_node_path.getTransform (motion_trail.root_node_path); - # transform = transform_state.getMat ( ) - pass - else: - pass - - net_matrix = motion_trail.getNetTransform ( ).getMat ( ) - if (motion_trail.previous_matrix != None): - -# i_matrix = Mat4 (Mat4.identMat ( )) -# print "i matrix" -# self.print_matrix (i_matrix) - -# print "net matrix" -# self.print_matrix (net_matrix) - -# print "previous matrix" -# self.print_matrix (motion_trail.previous_matrix) - -# print "previous rel matrix" -# self.print_matrix (motion_trail.previous_rel_matrix) - -# matrix = Mat4 (net_matrix) -# matrix.invertInPlace ( ) -# print "inverse matrix" -# self.print_matrix (matrix) - - relative_matrix = Mat4 (Mat4.identMat ( )) - relative_matrix.multiply (matrix, motion_trail.previous_matrix) - print "relative_matrix #1" - self.print_matrix (relative_matrix) - - relative_matrix.multiply (motion_trail.previous_matrix, matrix) - print "relative_matrix #2" - self.print_matrix (relative_matrix) - - motion_trail.previous_matrix = Mat4 (net_matrix) - motion_trail.previous_rel_matrix = Mat4 (net_matrix) - """ - - """ - current_matrix = Mat4.translateMat (Vec3 (0.0, 8.0, 0.0)) - - inverse_matrix = Mat4 (current_matrix) - inverse_matrix.invertInPlace ( ) - - previous_matrix = Mat4.translateMat (Vec3 (0.0, 5.0, 0.0)) - - relative_matrix = Mat4 (Mat4.identMat ( )) - relative_matrix.multiply (inverse_matrix, previous_matrix) - print "relative_matrix 111", relative_matrix.__repr__ ( ) - - relative_matrix = Mat4 (Mat4.identMat ( )) - relative_matrix.multiply (previous_matrix, inverse_matrix) - print "relative_matrix 222", relative_matrix.__repr__ ( ) - """ - if (motion_trail.root_node_path and (motion_trail.relative_to_render == False)): transform = motion_trail.getMat(motion_trail.root_node_path) else: transform = Mat4 (motion_trail.getNetTransform ( ).getMat ( )) - + if (transform != None): motion_trail.update_motion_trail (current_time, transform) - -# print "task update" index += 1 @@ -250,11 +161,11 @@ class MotionTrail(NodePath, DirectObject): motion_trail_vertex = MotionTrailVertex (vertex_id, vertex_function, context) total_vertices = len (self.vertex_list) - + self.vertex_list [total_vertices : total_vertices] = [motion_trail_vertex] self.total_vertices = len (self.vertex_list) - + return motion_trail_vertex def set_vertex_color (self, vertex_id, start_color, end_color): @@ -262,23 +173,23 @@ class MotionTrail(NodePath, DirectObject): motion_trail_vertex = self.vertex_list [vertex_id] motion_trail_vertex.start_color = start_color motion_trail_vertex.end_color = end_color - + def set_texture (self, texture): - self.texture = texture + self.texture = texture self.geom_node_path.setTexture (texture) - + # texture.setWrapU(Texture.WMClamp) # texture.setWrapV(Texture.WMClamp) - + return def update_vertices (self): total_vertices = len (self.vertex_list) - + self.total_vertices = total_vertices - if (total_vertices >= 2): + if (total_vertices >= 2): vertex_index = 0 while (vertex_index < total_vertices): motion_trail_vertex = self.vertex_list [vertex_index] @@ -296,9 +207,9 @@ class MotionTrail(NodePath, DirectObject): motion_trail_vertex.v = float_vertex_index / float_total_vertices vertex_index += 1 float_vertex_index += 1.0 - + # print "motion_trail_vertex.v", motion_trail_vertex.v - + return def register_motion_trail (self): @@ -306,34 +217,34 @@ class MotionTrail(NodePath, DirectObject): return def unregister_motion_trail (self): - if (self in MotionTrail.motion_trail_list): + if (self in MotionTrail.motion_trail_list): MotionTrail.motion_trail_list.remove (self) return - + def begin_geometry (self): self.vertex_index = 0; if (self.texture != None): - self.format = GeomVertexFormat.getV3c4t2 ( ) + self.format = GeomVertexFormat.getV3c4t2 ( ) else: - self.format = GeomVertexFormat.getV3c4 ( ) - - self.vertex_data = GeomVertexData ("vertices", self.format, Geom.UHStatic) + self.format = GeomVertexFormat.getV3c4 ( ) - self.vertex_writer = GeomVertexWriter (self.vertex_data, "vertex") + self.vertex_data = GeomVertexData ("vertices", self.format, Geom.UHStatic) + + self.vertex_writer = GeomVertexWriter (self.vertex_data, "vertex") self.color_writer = GeomVertexWriter (self.vertex_data, "color") if (self.texture != None): self.texture_writer = GeomVertexWriter (self.vertex_data, "texcoord") - - self.triangles = GeomTriangles (Geom.UHStatic) - + + self.triangles = GeomTriangles (Geom.UHStatic) + def add_geometry_quad (self, v0, v1, v2, v3, c0, c1, c2, c3, t0, t1, t2, t3): - - self.vertex_writer.addData3f (v0 [0], v0 [1], v0 [2]) - self.vertex_writer.addData3f (v1 [0], v1 [1], v1 [2]) - self.vertex_writer.addData3f (v2 [0], v2 [1], v2 [2]) - self.vertex_writer.addData3f (v3 [0], v3 [1], v3 [2]) + + self.vertex_writer.addData3f (v0 [0], v0 [1], v0 [2]) + self.vertex_writer.addData3f (v1 [0], v1 [1], v1 [2]) + self.vertex_writer.addData3f (v2 [0], v2 [1], v2 [2]) + self.vertex_writer.addData3f (v3 [0], v3 [1], v3 [2]) self.color_writer.addData4f (c0 [0], c0 [1], c0 [2], c0 [3]) self.color_writer.addData4f (c1 [0], c1 [1], c1 [2], c1 [3]) @@ -347,77 +258,77 @@ class MotionTrail(NodePath, DirectObject): self.texture_writer.addData2f (t3 [0], t3 [1]) vertex_index = self.vertex_index; - - self.triangles.addVertex (vertex_index + 0) - self.triangles.addVertex (vertex_index + 1) - self.triangles.addVertex (vertex_index + 2) - self.triangles.closePrimitive ( ) - self.triangles.addVertex (vertex_index + 1) - self.triangles.addVertex (vertex_index + 3) - self.triangles.addVertex (vertex_index + 2) - self.triangles.closePrimitive ( ) + self.triangles.addVertex (vertex_index + 0) + self.triangles.addVertex (vertex_index + 1) + self.triangles.addVertex (vertex_index + 2) + self.triangles.closePrimitive ( ) + + self.triangles.addVertex (vertex_index + 1) + self.triangles.addVertex (vertex_index + 3) + self.triangles.addVertex (vertex_index + 2) + self.triangles.closePrimitive ( ) self.vertex_index += 4 def end_geometry (self): - self.geometry = Geom (self.vertex_data) - self.geometry.addPrimitive (self.triangles) + self.geometry = Geom (self.vertex_data) + self.geometry.addPrimitive (self.triangles) - self.geom_node.removeAllGeoms ( ) - self.geom_node.addGeom (self.geometry) + self.geom_node.removeAllGeoms ( ) + self.geom_node.addGeom (self.geometry) def check_for_update (self, current_time): - + state = False if ((current_time - self.last_update_time) >= self.sampling_time): - state = True - + state = True + if (self.pause): state = False - + update = state and self.enable - + return state - + def update_motion_trail (self, current_time, transform): if (self.check_for_update (current_time)): - + color_scale = self.color_scale; if (self.fade): - elapsed_time = current_time - self.fade_start_time + elapsed_time = current_time - self.fade_start_time if (elapsed_time < 0.0): elapsed_time = 0.0 print "elapsed_time < 0", elapsed_time - + if (elapsed_time < self.fade_time): color_scale = (1.0 - (elapsed_time / self.fade_time)) * color_scale else: color_scale = 0.0 self.fade_end = True - + self.last_update_time = current_time # remove expired frames minimum_time = current_time - self.time_window - + """ print "*** minimum_time", minimum_time """ - + index = 0 last_frame_index = len (self.frame_list) - 1 - + while (index <= last_frame_index): motion_trail_frame = self.frame_list [last_frame_index - index] if (motion_trail_frame.time >= minimum_time): break - index += 1 + index += 1 if (index > 0): self.frame_list [last_frame_index - index: last_frame_index + 1] = [ ] @@ -425,158 +336,354 @@ class MotionTrail(NodePath, DirectObject): # add new frame to beginning of list motion_trail_frame = MotionTrailFrame (current_time, transform) self.frame_list = [motion_trail_frame] + self.frame_list - + # convert frames and vertices to geometry total_frames = len (self.frame_list) - - """ - print "total_frames", total_frames - index = 0; + # print "total_frames", total_frames + + """ + index = 0; while (index < total_frames): motion_trail_frame = self.frame_list [index] - print "frame time", index, motion_trail_frame.time - index += 1 + print "frame time", index, motion_trail_frame.time + index += 1 """ - + if ((total_frames >= 2) and (self.total_vertices >= 2)): self.begin_geometry ( ) - total_segments = total_frames - 1 - last_motion_trail_frame = self.frame_list [total_segments] - minimum_time = last_motion_trail_frame.time delta_time = current_time - minimum_time # print "minimum_time", minimum_time -# print "delta_time", delta_time - +# print "delta_time", delta_time if (self.calculate_relative_matrix): inverse_matrix = Mat4 (transform) - inverse_matrix.invertInPlace ( ) + inverse_matrix.invertInPlace ( ) # inverse_matrix.transposeInPlace ( ) - - """ + + """ print "current matrix" self.print_matrix (transform) print "inverse current matrix" self.print_matrix (inverse_matrix) - """ + """ + + if (self.use_nurbs and (total_frames >= 5)): - segment_index = 0 - while (segment_index < total_segments): - motion_trail_frame_start = self.frame_list [segment_index] - motion_trail_frame_end = self.frame_list [segment_index + 1] + total_distance = 0.0 + vector = Vec3 ( ) - start_t = (motion_trail_frame_start.time - minimum_time) / delta_time - end_t = (motion_trail_frame_end.time - minimum_time) / delta_time - - st = start_t - et = end_t - -# print "st", st -# print "et", et + nurbs_curve_evaluator_list = [ ] - if (self.square_t): - start_t *= start_t - end_t *= end_t - -# print "start_t", start_t -# print "end_t", end_t - - vertex_segement_index = 0 total_vertex_segments = self.total_vertices - 1 - if (self.calculate_relative_matrix): - start_transform = Mat4 ( ) - end_transform = Mat4 ( ) -# start_transform.multiply (inverse_matrix, motion_trail_frame_start.transform) -# end_transform.multiply (inverse_matrix, motion_trail_frame_end.transform) + # create a NurbsCurveEvaluator for each vertex (the starting point for the trail) + index = 0 + while (index < self.total_vertices): + nurbs_curve_evaluator = NurbsCurveEvaluator ( ) + nurbs_curve_evaluator.reset (total_segments) + nurbs_curve_evaluator_list = nurbs_curve_evaluator_list + [nurbs_curve_evaluator] + index += 1 - start_transform.multiply (motion_trail_frame_start.transform, inverse_matrix) - end_transform.multiply (motion_trail_frame_end.transform, inverse_matrix) + # add vertices to each NurbsCurveEvaluator + segment_index = 0 + while (segment_index < total_segments): + motion_trail_frame_start = self.frame_list [segment_index] + motion_trail_frame_end = self.frame_list [segment_index + 1] -# start_transform.transposeInPlace ( ) -# end_transform.transposeInPlace ( ) + vertex_segement_index = 0 - """ - print "start matrix" - self.print_matrix (motion_trail_frame_start.transform) - print "relative_matrix 111" - self.print_matrix (start_transform) + if (self.calculate_relative_matrix): + start_transform = Mat4 ( ) + end_transform = Mat4 ( ) + + start_transform.multiply (motion_trail_frame_start.transform, inverse_matrix) + end_transform.multiply (motion_trail_frame_end.transform, inverse_matrix) + + else: + start_transform = motion_trail_frame_start.transform + end_transform = motion_trail_frame_end.transform + + motion_trail_vertex_start = self.vertex_list [0] + + v0 = start_transform.xform (motion_trail_vertex_start.vertex) + v2 = end_transform.xform (motion_trail_vertex_start.vertex) + + nurbs_curve_evaluator = nurbs_curve_evaluator_list [vertex_segement_index] + +# print "nurbs_curve_evaluator", nurbs_curve_evaluator, "index", (vertex_segement_index) + + nurbs_curve_evaluator.setVertex (segment_index, v0) + + while (vertex_segement_index < total_vertex_segments): + + motion_trail_vertex_start = self.vertex_list [vertex_segement_index] + motion_trail_vertex_end = self.vertex_list [vertex_segement_index + 1] + + v1 = start_transform.xform (motion_trail_vertex_end.vertex) + v3 = end_transform.xform (motion_trail_vertex_end.vertex) + + nurbs_curve_evaluator = nurbs_curve_evaluator_list [vertex_segement_index + 1] + +# print "nurbs_curve_evaluator", nurbs_curve_evaluator, "index", (vertex_segement_index + 1) + + nurbs_curve_evaluator.setVertex (segment_index, v1) + + """ + print v0 + print v1 + print v2 + print v3 + """ + + if (vertex_segement_index == (total_vertex_segments - 1)): +# if (vertex_segement_index == 0): + v = v1 - v3 + vector.set (v[0], v[1], v[2]) + distance = vector.length() + total_distance += distance +# print "DISTANCE", distance + + vertex_segement_index += 1 + + segment_index += 1 + + +# print "TOTAL DISTANCE", total_distance, "SEGMENTS", total_distance / self.resolution_distance + + # evaluate NurbsCurveEvaluator for each vertex + index = 0 + nurbs_curve_result_list = [ ] + while (index < self.total_vertices): + nurbs_curve_evaluator = nurbs_curve_evaluator_list [index] + nurbs_curve_result = nurbs_curve_evaluator.evaluate ( ) + nurbs_curve_result_list = nurbs_curve_result_list + [nurbs_curve_result] - print "end matrix" - self.print_matrix (motion_trail_frame_end.transform) - print "relative_matrix 222" - self.print_matrix (end_transform) - """ + nurbs_start_t = nurbs_curve_result.getStartT() + nurbs_end_t = nurbs_curve_result.getEndT() - else: - start_transform = motion_trail_frame_start.transform - end_transform = motion_trail_frame_end.transform +# print "nurbs_start_t", nurbs_start_t, "nurbs_end_t", nurbs_end_t - motion_trail_vertex_start = self.vertex_list [0] + index += 1 - v0 = start_transform.xform (motion_trail_vertex_start.vertex) - v2 = end_transform.xform (motion_trail_vertex_start.vertex) + # create quads from NurbsCurveResult + total_curve_segments = total_distance / self.resolution_distance + if (total_curve_segments < total_segments): + total_curve_segments = total_segments; - vertex_start_color = motion_trail_vertex_start.end_color + (motion_trail_vertex_start.start_color - motion_trail_vertex_start.end_color) - color_start_t = color_scale * start_t - color_end_t = color_scale * end_t - c0 = vertex_start_color * color_start_t - c2 = vertex_start_color * color_end_t +# print "total_curve_segments", total_curve_segments - t0 = Vec2 (st, motion_trail_vertex_start.v) - t2 = Vec2 (et, motion_trail_vertex_start.v) + v0 = Vec3 ( ) + v1 = Vec3 ( ) + v2 = Vec3 ( ) + v3 = Vec3 ( ) - while (vertex_segement_index < total_vertex_segments): - - motion_trail_vertex_start = self.vertex_list [vertex_segement_index] - motion_trail_vertex_end = self.vertex_list [vertex_segement_index + 1] - - v1 = start_transform.xform (motion_trail_vertex_end.vertex) - v3 = end_transform.xform (motion_trail_vertex_end.vertex) - - """ - print v0 - print v1 - print v2 - print v3 - """ - - # color - vertex_end_color = motion_trail_vertex_end.end_color + (motion_trail_vertex_end.start_color - motion_trail_vertex_end.end_color) - - c1 = vertex_end_color * color_start_t - c3 = vertex_end_color * color_end_t - - # uv - t1 = Vec2 (st, motion_trail_vertex_end.v) - t3 = Vec2 (et, motion_trail_vertex_end.v) - - self.add_geometry_quad (v0, v1, v2, v3, c0, c1, c2, c3, t0, t1, t2, t3) - - # reuse calculations - v0 = v1 - v2 = v3 - - c0 = c1 - c2 = c3 - - t0 = t1 - t2 = t3 - - vertex_segement_index += 1 - - segment_index += 1 + def one_minus_x (x): + x = 1.0 - x + if (x < 0.0): + x = 0.0 + return x + curve_segment_index = 0.0 + while (curve_segment_index < total_curve_segments): + + vertex_segement_index = 0 + + if (True): + st = curve_segment_index / total_curve_segments + et = (curve_segment_index + 1.0) / total_curve_segments + else: + st = curve_segment_index / total_segments + et = (curve_segment_index + 1.0) / total_segments + + start_t = st + end_t = et + + if (self.square_t): + start_t *= start_t + end_t *= end_t + + motion_trail_vertex_start = self.vertex_list [0] + + vertex_start_color = motion_trail_vertex_start.end_color + (motion_trail_vertex_start.start_color - motion_trail_vertex_start.end_color) + color_start_t = color_scale * start_t + color_end_t = color_scale * end_t + c0 = vertex_start_color * one_minus_x (color_start_t) + c2 = vertex_start_color * one_minus_x (color_end_t) + +# c = 1.0 - st +# c0.set(c,c,c,c) +# c2.set(c,c,c,c) + + t0 = Vec2 (one_minus_x (st), motion_trail_vertex_start.v) + t2 = Vec2 (one_minus_x (et), motion_trail_vertex_start.v) + + while (vertex_segement_index < total_vertex_segments): + start_nurbs_curve_result = nurbs_curve_result_list [vertex_segement_index] + end_nurbs_curve_result = nurbs_curve_result_list [vertex_segement_index + 1] + + start_nurbs_start_t = start_nurbs_curve_result.getStartT() + start_nurbs_end_t = start_nurbs_curve_result.getEndT() + end_nurbs_start_t = end_nurbs_curve_result.getStartT() + end_nurbs_end_t = end_nurbs_curve_result.getEndT() + + + start_delta_t = (start_nurbs_end_t - start_nurbs_start_t) + end_delta_t = (end_nurbs_end_t - end_nurbs_start_t) + + start_nurbs_curve_result.evalPoint (start_nurbs_start_t + (start_delta_t * st), v0); + end_nurbs_curve_result.evalPoint (end_nurbs_start_t + (end_delta_t * st), v1); + + start_nurbs_curve_result.evalPoint (start_nurbs_start_t + (start_delta_t * et), v2); + end_nurbs_curve_result.evalPoint (end_nurbs_start_t + (end_delta_t * et), v3); + + # color + vertex_end_color = motion_trail_vertex_end.end_color + (motion_trail_vertex_end.start_color - motion_trail_vertex_end.end_color) + + c1 = vertex_end_color * one_minus_x (color_start_t) + c3 = vertex_end_color * one_minus_x (color_end_t) + +# c1.set(c,c,c,c) +# c3.set(c,c,c,c) + + # uv + t1 = Vec2 (one_minus_x (st), motion_trail_vertex_end.v) + t3 = Vec2 (one_minus_x (et), motion_trail_vertex_end.v) + + self.add_geometry_quad (v0, v1, v2, v3, c0, c1, c2, c3, t0, t1, t2, t3) + + # reuse calculations +# v0 = v1 +# v2 = v3 + + c0 = c1 + c2 = c3 + + t0 = t1 + t2 = t3 + + vertex_segement_index += 1 + + curve_segment_index += 1.0 + + + else: + + segment_index = 0 + while (segment_index < total_segments): + motion_trail_frame_start = self.frame_list [segment_index] + motion_trail_frame_end = self.frame_list [segment_index + 1] + + start_t = (motion_trail_frame_start.time - minimum_time) / delta_time + end_t = (motion_trail_frame_end.time - minimum_time) / delta_time + + st = start_t + et = end_t + + # print "st", st + # print "et", et + + if (self.square_t): + start_t *= start_t + end_t *= end_t + + # print "start_t", start_t + # print "end_t", end_t + + vertex_segement_index = 0 + total_vertex_segments = self.total_vertices - 1 + + if (self.calculate_relative_matrix): + start_transform = Mat4 ( ) + end_transform = Mat4 ( ) + # start_transform.multiply (inverse_matrix, motion_trail_frame_start.transform) + # end_transform.multiply (inverse_matrix, motion_trail_frame_end.transform) + + start_transform.multiply (motion_trail_frame_start.transform, inverse_matrix) + end_transform.multiply (motion_trail_frame_end.transform, inverse_matrix) + + # start_transform.transposeInPlace ( ) + # end_transform.transposeInPlace ( ) + + """ + print "start matrix" + self.print_matrix (motion_trail_frame_start.transform) + print "relative_matrix 111" + self.print_matrix (start_transform) + + print "end matrix" + self.print_matrix (motion_trail_frame_end.transform) + print "relative_matrix 222" + self.print_matrix (end_transform) + """ + + else: + start_transform = motion_trail_frame_start.transform + end_transform = motion_trail_frame_end.transform + + motion_trail_vertex_start = self.vertex_list [0] + + v0 = start_transform.xform (motion_trail_vertex_start.vertex) + v2 = end_transform.xform (motion_trail_vertex_start.vertex) + + vertex_start_color = motion_trail_vertex_start.end_color + (motion_trail_vertex_start.start_color - motion_trail_vertex_start.end_color) + color_start_t = color_scale * start_t + color_end_t = color_scale * end_t + c0 = vertex_start_color * color_start_t + c2 = vertex_start_color * color_end_t + + t0 = Vec2 (st, motion_trail_vertex_start.v) + t2 = Vec2 (et, motion_trail_vertex_start.v) + + while (vertex_segement_index < total_vertex_segments): + + motion_trail_vertex_start = self.vertex_list [vertex_segement_index] + motion_trail_vertex_end = self.vertex_list [vertex_segement_index + 1] + + v1 = start_transform.xform (motion_trail_vertex_end.vertex) + v3 = end_transform.xform (motion_trail_vertex_end.vertex) + + """ + print v0 + print v1 + print v2 + print v3 + """ + # color + vertex_end_color = motion_trail_vertex_end.end_color + (motion_trail_vertex_end.start_color - motion_trail_vertex_end.end_color) + + c1 = vertex_end_color * color_start_t + c3 = vertex_end_color * color_end_t + + # uv + t1 = Vec2 (st, motion_trail_vertex_end.v) + t3 = Vec2 (et, motion_trail_vertex_end.v) + + self.add_geometry_quad (v0, v1, v2, v3, c0, c1, c2, c3, t0, t1, t2, t3) + + # reuse calculations + v0 = v1 + v2 = v3 + + c0 = c1 + c2 = c3 + + t0 = t1 + t2 = t3 + + vertex_segement_index += 1 + + segment_index += 1 + self.end_geometry ( ) - + return - + def enable_motion_trail(self, enable): self.enable = enable return @@ -587,7 +694,7 @@ class MotionTrail(NodePath, DirectObject): def reset_motion_trail_geometry(self): if (self.geom_node != None): - self.geom_node.removeAllGeoms ( ) + self.geom_node.removeAllGeoms ( ) return def attach_motion_trail (self): @@ -608,7 +715,7 @@ class MotionTrail(NodePath, DirectObject): self.reset_motion_trail_geometry ( ) self.playing = False; return - + def set_fade (self, time, current_time): if (self.pause == False): self.fade_color_scale = 1.0 @@ -618,9 +725,9 @@ class MotionTrail(NodePath, DirectObject): else: self.fade_start_time = current_time self.fade_time = time - self.fade = True - return - + self.fade = True + return + def pause_motion_trail(self, current_time): if (self.pause == False): self.pause_time = current_time @@ -638,7 +745,7 @@ class MotionTrail(NodePath, DirectObject): motion_trail_frame.time += delta_time frame_index += 1 - if (self.fade): + if (self.fade): self.fade_start_time += delta_time self.pause = False @@ -649,3 +756,4 @@ class MotionTrail(NodePath, DirectObject): self.resume_motion_trail (current_time) else: self.pause_motion_trail (current_time) +