
    l0j/                     h    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dS )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!N )	r   is_instance_namedmesh_to_vertexlistpath_to_vertexlistpoints_to_vertexlistverticesr
   as_boxes
ValueError)geometrykwargss     T/home/wildlama/miniconda3/envs/lam/lib/python3.11/site-packages/trimesh/rendering.pyconvert_to_vertexlistr      s     h	22 D!(55f555		&	1	1 D "(55f555		,	7	7 
D#H$5XXhoXQWXXX		)	4	4 D#H77777		+	6	6 D!"3("3"="=f"="=HHHHHBCCC    T`  c                    t          | j        d          r{t          | j                  }| j                            d                                          }| j                            d                                          }| j                            d                                          }| j        j        }| j        j	        }	t          |	d          r
|	j
        du }
nt          |	d          r
|	j        du }
nd}
||
st          |          |k    rt          |	j        |          }n%|j        d         dk    r|ddddf         }d	|                    t           j                                      d                                          f}n|rt          | j                  |k     r| j        } t          | j                  }| j                            d                                          }| j                            d                                          }| j                            d                                          }t          | j        j        |          }nt          | j                  d
z  }t!          j        | j        d                              d                                          }| j                            d                                          }t!          j        |                                          }t!          j        | j        j        d                              d          }t          ||          }|t2          ||d|fd|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

    uvimageNbaseColorTextureTr      z
t2f/static   )r   r!   )r   r   
v3f/staticz
n3f/static)hasattrvisuallenr   vertex_normalsreshapetolistfacesr   materialr   r   colors_to_gl
main_colorshapeastypenpfloat64smooth_shadedvertex_colors	trianglestileface_normalsarangeface_colorsGL_TRIANGLES)meshgroupsmoothsmooth_thresholdvertex_countnormalsr)   r   r   r*   no_imagecolor_glr
   argss                 r   r   r   4   s   . t{D!! 264=))%--b1188::
""2&&--//=((,,3355 [^ ;'8W%% 	~-HHX122 	0D8HHH ::SWW%<%< $H$7FFHH x{Q2A2Y$bii
&;&;&C&CB&G&G&N&N&P&PQHH	 6C
OO&666 !4=))%--b1188::
""2&&--//=((,,3355 9<HH 4>**Q.'$+V44<<R@@GGII>))"--4466	,''..000&99AA'JJ55
 		x 	wD Kr   c                 f  
 | j         

fd| j        D             }t          j        |          }t	          |          }t          j        
d          rJ|                    d          }t          j        |t          j	        t	          |                    f          }t          j
        |                                          }| j        }|1t          j        d t          || j                  D                       }t          ||          }|t           ||d|                    d          f|f}	|	S )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
    c                 ^    g | ])}t          j        |                                        *S r   )r   stack_linesdiscrete).0er   s     r   
<listcomp>z&path_to_vertexlist.<locals>.<listcomp>   s0    MMM!t

8 4 455MMMr   r   r    Nc                     g | ]H\  }}t          j        t          |          d f          |z                      t           j                  IS r   )r/   onesr%   r.   uint8)rF   scs      r   rH   z&path_to_vertexlist.<locals>.<listcomp>   sU       Aq #a&&!%%)11"(;;  r   )countr"   r   )r   entitiesr   vstack_emptyr%   is_shaper'   r/   column_stackzerosr6   r(   r
   vstackzipr+   GL_LINES)pathr:   r   stackedlinesrP   indexr
   	gl_colorsrA   r   s             @r   r   r      s:   $ }H NMMMt}MMMGg&&EJJE }Xw'' ?g&&U(<(< =>>Ie##%%E [F 55  
 
 V5111I 		u}}R(()D Kr   c                    t          j        | t           j                  } t          j        | d          r6t          j        | t          j        t          |                     f          } n$t          j        | d          st          d          t          j	        t          |                     
                                }t          |           t          ||d|                     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
    dtyperI   )r   r!   zPointcloud must be (n,3)!r"   r   )r/   
asanyarrayr0   r   rS   rT   rU   r%   r   r6   r(   	GL_POINTSr'   r+   )pointsr
   r:   r   r\   rA   s         r   r   r      s    & ]6444F}VW%% 6&"(3v;;*?*?!@AA]67++ 64555Ic&kk""))++E 	F	v~~b))*VS[[))D Kr   c                    t          j        |           } t          |          }dddd}| j        j        |v r|| j        j                 }nd}|Rt          j        | |df          r;d| j        d          | d}|                     d	          	                                }n|a| j        d
v rXt          j
        || j        f| j                  | z                      d	          	                                }d| j         | d}n@t          j        g d|df                              d	          	                                }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)re   iuN)r!   r   rO   r   z/staticr   ))r!   rK   r_   )        ri   ri   z
c3f/static)r/   ra   intr`   kindr   rS   r-   r'   r(   rL   sizer4   )r
   rP   colors_dtypesr`   colors_typer]   s         r   r+   r+      sU   $ ]6""FJJECc22M|M))fl/0T]6E6?CC9&,q/95999NN2&&--//				v||;; WeV[)>>>GWR[[VXX 	 6&+5u555 GOOOeQZ88@@DDKKMM	"	!!r   c                    ddl }t          | d          r| j        }nt          | d          r| j        }ndS |dS |rddlm}  ||          }t          j                    5 }|                    |d           |	                    d           |j        
                    d	|
          }ddd           n# 1 swxY w Y   |                                }|S )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.texturerp   r   BytesIOsaveseekloadget_texture)r*   upsizeru   imgrp   re   gl_imagetextures           r   material_to_texturer   !  s:   $ MMM x!! n	-	.	. 't {t   000000l3 
 >15!!!	q			<$$f1$==> > > > > > > > > > > > > > > ""$$GNs   !A	B66B:=B:c                     ddl m}  |j        dz  t          j        | t          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_   )ru   r   GLfloatr/   arrayfloat32Travel)matrixr   s     r   matrix_to_glr   V  sK      BJObhvRZ@@@BHHJJKKr   c                     ddl m} t          j        |           } t	          |          dk    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   )ru   r   r/   r   r%   appendr   )r   rA   r   vectors       r   vector_to_glr   k  sa    
 HUOOE
4yy1}}	%&&%bj3u::%.FMr   c                 "   ddl m} t          | 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!   )ru   r   r   colorr.   r/   r0   r%   GL_POSITIONGL_SPECULAR
GL_DIFFUSE
GL_AMBIENT)light	transformlightNr   gl_colorgl_positionrA   s          r   light_to_glr   y  s    (  EK..rz::UBCCHx==A y!Q/00K 
-	*	)	)	D Kr   )NTr   )N)NN)T)__doc__numpyr/    r   rb   rX   r8   r   r   r   r   r+   r   r   r   r   r   r   r   <module>r      s               %. !	8\ D  D  DFW W W Wt5 5 5 5p$ $ $ $N1" 1" 1"h2 2 2 2jL L L*  $ $ $ $ $r   