import numpy as np
from PIL import Image
VIEWS={ # forward dir (camera looks along), up
 'front':((0,0,1),(0,1,0)),'back':((0,0,-1),(0,1,0)),
 'left':((1,0,0),(0,1,0)),'right':((-1,0,0),(0,1,0)),
 'top':((0,-1,0),(0,0,-1)),'bottom':((0,1,0),(0,0,1))}
def vnormals(V,F):
    fn=np.cross(V[F[:,1]]-V[F[:,0]],V[F[:,2]]-V[F[:,0]])
    N=np.zeros_like(V)
    for k in range(3): np.add.at(N,F[:,k],fn)
    n=np.linalg.norm(N,axis=1,keepdims=True); return N/np.maximum(n,1e-12)
def camera(view,center,extent,persp=False):
    if view=='perspective':
        az,el=np.radians(-35),np.radians(18)   # camera at front-right-ish (viewer's -z side)
        d=np.array([np.sin(az)*np.cos(el)*-1,-np.sin(el)*-1*-1,np.cos(az)*np.cos(el)])
        f=np.array([np.sin(az)*np.cos(el),-np.sin(el),np.cos(az)*np.cos(el)])  # looking dir
        # camera sits at front (-z) side: look along +z rotated
        f=np.array([-np.sin(np.radians(35))*np.cos(el),-np.sin(el),np.cos(np.radians(35))*np.cos(el)])
        up=np.array([0,1,0.])
    else:
        f=np.array(VIEWS[view][0],float); up=np.array(VIEWS[view][1],float)
    r=np.cross(f,up); r/=np.linalg.norm(r); u=np.cross(r,f)
    return f,r,u
def render(meshes,view,size=800,extent=None,center=None,bg=(255,255,255),persp=False,mask_only=False):
    """meshes: list of (V,F,color). returns RGB uint8 image and per-mesh id buffer."""
    allV=np.vstack([m[0] for m in meshes])
    if center is None: center=(allV.min(0)+allV.max(0))/2
    if extent is None: extent=np.linalg.norm(allV.max(0)-allV.min(0))*0.62
    f,r,u=camera(view,center,extent)
    isp=(view=='perspective')
    img=np.zeros((size,size,3),np.float32); img[:]=bg
    zb=np.full((size,size),1e9); idb=np.full((size,size),-1,np.int32)
    L=-f*0.7+u*0.5+r*-0.3; L/=np.linalg.norm(L)
    for mi,(V,F,col) in enumerate(meshes):
        N=vnormals(V,F)
        rel=V-center
        x=rel@r; y=rel@u; z=rel@f
        if isp:
            D=extent*3.2; s=D/(D+z); x=x*s; y=y*s
        sx=(x/extent*0.5+0.5)*size; sy=(0.5-y/extent*0.5)*size
        col=np.array(col,float)
        for tri in F:
            a,b,c=tri
            xs=sx[tri]; ys=sy[tri]
            x0=max(int(np.floor(xs.min())),0); x1=min(int(np.ceil(xs.max())),size-1)
            y0=max(int(np.floor(ys.min())),0); y1=min(int(np.ceil(ys.max())),size-1)
            if x1<x0 or y1<y0: continue
            den=(ys[1]-ys[2])*(xs[0]-xs[2])+(xs[2]-xs[1])*(ys[0]-ys[2])
            if abs(den)<1e-9: continue
            gx,gy=np.meshgrid(np.arange(x0,x1+1)+0.5,np.arange(y0,y1+1)+0.5)
            w0=((ys[1]-ys[2])*(gx-xs[2])+(xs[2]-xs[1])*(gy-ys[2]))/den
            w1=((ys[2]-ys[0])*(gx-xs[2])+(xs[0]-xs[2])*(gy-ys[2]))/den
            w2=1-w0-w1
            m=(w0>=-1e-4)&(w1>=-1e-4)&(w2>=-1e-4)
            if not m.any(): continue
            zz=w0*z[a]+w1*z[b]+w2*z[c]
            sub=zb[y0:y1+1,x0:x1+1]
            mm=m&(zz<sub)
            if not mm.any(): continue
            sub[mm]=zz[mm]; idb[y0:y1+1,x0:x1+1][mm]=mi
            if not mask_only:
                nn=(w0[mm,None]*N[a]+w1[mm,None]*N[b]+w2[mm,None]*N[c])
                nn/=np.maximum(np.linalg.norm(nn,axis=1,keepdims=True),1e-9)
                lam=np.clip(-(nn@f)*0.0+(nn@L),0,1)
                head=np.clip(-(nn@f),0,1)
                sh=0.30+0.45*lam+0.35*head
                img[y0:y1+1,x0:x1+1][mm]=np.clip(col[None,:]*sh[:,None],0,255)
    return img.astype(np.uint8),idb,zb