
    -i0                     f    d Z ddlZddlmZ d\  ZZZd ZddZ	ddZ
dd	Zd
 ZddZd Zd Zd Zy)z]
rendering.py
--------------

Functions to convert trimesh objects to pyglet/opengl objects.
    N   )util)r   r      c                    t        j                  | d      rt        | fi |S t        j                  | d      rt        | fi |S t        j                  | d      r"t	        | j
                  fd| j                  i|S t        j                  | d      rt	        | fi |S t        j                  | d      rt         | j                  di |fi |S t        d      )	a[  
    Try to convert various geometry objects to the constructor
    args for a pyglet indexed vertex list.

    Parameters
    ------------
    obj : Trimesh, Path2D, Path3D, (n,2) float, (n,3) float
      Object to render

    Returns
    ------------
    args : tuple
      Args to be passed to pyglet indexed vertex list
      constructor.
    TrimeshPath
PointCloudcolorsndarray	VoxelGridz'Geometry passed is not a viewable type! )	r   is_instance_namedmesh_to_vertexlistpath_to_vertexlistpoints_to_vertexlistverticesr
   as_boxes
ValueError)geometrykwargss     M/mnt/e/genesis-system/.venv/lib/python3.12/site-packages/trimesh/rendering.pyconvert_to_vertexlistr      s      h	2!(5f55			&	1 "(5f55			,	7#H$5$5XhooXQWXX			)	4#H777			+	6!"3("3"3"=f"=HHHBCC    c           	         t        | j                  j                        dk(  rd| j                  j                  d   dk(  rHt        j                  | j                  t        j
                  t        | j                              f      }n| j                  }t        | j                  d      rt        |      }| j                  }| j                  }| j                  j                  }| j                  j                  }	t        |	d      r|	j                  du }
nt        |	d      r|	j                  du }
nd}
||
st        |      |k7  rt        |	j                  |      }n|j                  d   dkD  r|ddddf   }d|j!                  t        j"                        j%                  d	      j'                         f}n'|rtt        | j                        |k  r\| j(                  }|j                  }t        |      }|j                  }|j                  }t        |j                  j*                  |      }nt        | j                        d
z  }t        j,                  | j.                  d      }|| j                     }t        j0                  |t        j2                        }t        j,                  | j                  j4                  d      j%                  d      }t        ||      }|t6        ||j%                  d	      j'                         d|j%                  d	      j'                         fd|j%                  d	      j'                         f|f}|S )a  
    Convert a Trimesh object to arguments for an
    indexed vertex list constructor.

    Parameters
    -------------
    mesh : trimesh.Trimesh
      Mesh to be rendered
    group : str
      Rendering group for the vertex list
    smooth : bool
      Should we try to smooth shade the mesh
    smooth_threshold : int
      Maximum number of faces to smooth shade

    Returns
    --------------
    args : (7,) tuple
      Args for vertex list constructor

       r   uvimageNbaseColorTextureTz
t2f/static   )r   r    dtype)r   r   
v3f/staticz
n3f/static)lenr   shapenpcolumn_stackzeroshasattrvisualvertex_normalsfacesr   materialr   r   colors_to_gl
main_colorastypefloat64reshapetolistsmooth_shadedvertex_colorstileface_normalsarangeint64face_colorsGL_TRIANGLES)meshgroupsmoothsmooth_thresholdr   vertex_countnormalsr,   r   r-   no_imagecolor_glr
   argss                 r   r   r   4   s   . 4==1$)<)<Q)?1)D??DMM288C<N3O#PQ==t{{D!8}%%

 [[^^ ;;''8W%~~-HX1200D8HH :SW%< $H$7$7FH xx{Q2A2Y$bii

&;&C&CB&G&N&N&PQH	C

O&66 ##??8}'' ; ;\J 4::*''$++V4DJJ'		,bhh700&9AA'J5
 	b  "	x''+2245	wr*1134D Kr   c                 H   | j                   }| j                  D cg c]&  }t        j                  |j	                  |            ( }}t        j
                  |      }t        |      }t        j                  |d      rD|j                  d      }t        j                  |t        j                  t        |            f      }t        j                  |      j                         }| j                  }	|	zt        j                  t!        || j                        D 
cg c]E  \  }
}t        j"                  t        |
      df      |z  j%                  t        j&                        G c}}
      }	t)        |	|      }|t*        ||d|j                  d      f|f}|S c c}w c c}}
w )aY  
    Convert a Path3D object to arguments for a
    pyglet indexed vertex list constructor.

    Parameters
    -------------
    path : trimesh.path.Path3D object
      Mesh to be rendered
    group : str
      Rendering group for the vertex list

    Returns
    --------------
    args : (7,) tuple
      Args for vertex list constructor
    r   r   r   )countr#   r   )r   entitiesr   stack_linesdiscretevstack_emptyr$   is_shaper2   r&   r'   r(   r8   r3   r
   vstackziponesr0   uint8r.   GL_LINES)pathr=   r   r   estackedlinesrG   indexr
   sc	gl_colorsrD   s                 r   r   r      s_   $ }}H @D}}M!t

8 45MGMg&EJE }}Xw'g&U(< =>IIe##%E [[F  5Aq #a&!%)11"((;
 V51I 		u}}R()D KA Ns   +FA
F
c                    t        j                  | t         j                        } t        j                  | d      r4t        j
                  | t        j                  t        |             f      } n!t        j                  | d      st        d      t        j                  t        |             j                         }t        |       t        ||d| j                  d      ft        |t        |             f}|S )a  
    Convert a numpy array of 3D points to args for
    a vertex list constructor.

    Parameters
    -------------
    points : (n, 3) float
      Points to be rendered
    colors : (n, 3) or (n, 4) float
      Colors for each point
    group : str
      Rendering group for the vertex list

    Returns
    --------------
    args : (7,) tuple
      Args for vertex list constructor
    r!   rF   )r   r    zPointcloud must be (n,3)!r#   r   )r&   
asanyarrayr1   r   rL   r'   r(   r$   r   r8   r3   	GL_POINTSr2   r.   )pointsr
   r=   r   rV   rD   s         r   r   r      s    & ]]64F}}VW%&"((3v;*?!@A]]67+455IIc&k"))+E 	F	v~~b)*VS[)D Kr   c                    t        j                  |       } t        |      }dddd}| j                  j                  |v r|| j                  j                     }nd}|Pt        j                  | |df      r8d| j                  d    | d}| j                  d	      j                         }||fS |q| j                  d
v rct        j                  || j                  f| j                        | z  j                  d	      j                         }d| j                   | d}||fS t        j                  g d|df      j                  d	      j                         }d}||fS )a8  
    Given a list of colors (or None) return a GL-acceptable
    list of colors.

    Parameters
    ------------
    colors: (count, (3 or 4)) float
      Input colors as an array

    Returns
    ---------
    colors_type : str
      Color type
    colors_gl : (count,) list
      Colors to pass to pyglet
    fB)r_   iuN)r    r   rX   r   z/staticr   ))r    )r   r!   )        rc   rc   z
c3f/static)r&   r[   intr"   kindr   rL   r%   r2   r3   rO   sizer6   )r
   rG   colors_dtypesr"   colors_typerY   s         r   r.   r.      sQ   $ ]]6"FJECc2M||M)fll//0T]]6E6?C&,,q/*5'9NN2&--/	" 	!!! 
	v|||; WWeV[[)>GWR[VX 	 &++ugW5 	!!	 GGOeQZ8@@DKKM	"	!!r   c                    ddl }t        | d      r| j                  }nt        | d      r| j                  }ny|y|rddlm}  ||      }t        j                         5 }|j                  |d       |j                  d       |j                  j                  d	|
      }ddd       j                         }|S # 1 sw Y   xY w)a  
    Convert a trimesh.visual.texture.Material object into
    a pyglet-compatible texture object.

    Parameters
    --------------
    material : trimesh.visual.texture.Material
      Material to be converted
    upsize: bool
      If True, will upscale textures to their nearest power
      of two resolution to avoid weirdness

    Returns
    ---------------
    texture : pyglet.image.Texture
      Texture loaded into pyglet form
    r   Nr   r   r   )power_resizepng)formatz.png)filenamefile)pygletr)   r   r   visual.texturerj   r   BytesIOsaveseekloadget_texture)r-   upsizero   imgrj   r_   gl_imagetextures           r   material_to_texturerz   %  s    $  x!nn	-	.'' { 03 
 >15!	q	<<$$f1$=> ""$GN> >s   AB;;Cc                     ddl m}  |j                  dz  t        j                  | t        j
                        j                  j                          S )a9  
    Convert a numpy row-major homogeneous transformation matrix
    to a flat column-major GLfloat transformation.

    Parameters
    -------------
    matrix : (4,4) float
      Row-major homogeneous transform

    Returns
    -------------
    glmatrix : (16,) gl.GLfloat
      Transform in pyglet format
    r   gl   r!   )ro   r}   GLfloatr&   arrayfloat32Travel)matrixr}   s     r   matrix_to_glr   Z  s<      BJJObhhvRZZ@BBHHJKKr   c                     ddl m} t        j                  |       } t	        |      dkD  rt        j
                  | |      }  |j                  t	        |       z  |  }|S )z[
    Convert an array and an optional set of args into a
    flat vector of gl.GLfloat
    r   r|   )ro   r}   r&   r   r$   appendr   )r   rD   r}   vectors       r   vector_to_glr   o  sM    
 HHUOE
4y1}		%&%bjj3u:%.FMr   c                 4   ddl m} t        | j                  j	                  t
        j                        dz        }t        |      dk(  sJ t        |dddf         }||j                  |f||j                  |f||j                  |f||j                  |fg}|S )a  
    Convert trimesh.scene.lighting.Light objects into
    args for gl.glLightFv calls

    Parameters
    --------------
    light : trimesh.scene.lighting.Light
      Light object to be converted to GL
    transform : (4, 4) float
      Transformation matrix of light
    lightN : int
      Result of gl.GL_LIGHT0, gl.GL_LIGHT1, etc

    Returns
    --------------
    multiarg : [tuple]
      List of args to pass to gl.glLightFv eg:
      [gl.glLightfb(*a) for a in multiarg]
    r   r|   g     o@r   Nr    )ro   r}   r   colorr0   r&   r1   r$   GL_POSITIONGL_SPECULAR
GL_DIFFUSE
GL_AMBIENT)light	transformlightNr}   gl_colorgl_positionrD   s          r   light_to_glr   }  s    (  EKK..rzz:UBCHx=A y!Q/0K 
-	*	)	)	D Kr   )NTi`  )N)NN)T)__doc__numpyr&    r   r\   rQ   r;   r   r   r   r   r.   rz   r   r   r   r   r   r   <module>r      sV      %. !	8\ DF[|5p$N1"h2jL*$r   