__author__ = 'thoth'

import bpy
from mathutils import *

#
# this script creates several planes perpendicular to the camera to
#  "experimentally" verify my math about camera field-of-view
#

def create_planes(scn):
    cam = scn.camera

    lens = cam.data.lens
    ss = cam.data.sensor_width
    for i in range(5):
        name ="test plane %d"%i

        obj = bpy.data.objects.get(name)

        if obj is not None:
            obj.name = "discard"
            try:
                scn.objects.unlink(obj)
            except:
                pass

        mesh = bpy.data.meshes.new(name)

        z=-i*2
        w = z*ss/lens
        x = w/2
        y = w/2 * scn.render.resolution_y / scn.render.resolution_x


        verts = [
                cam.matrix_world * Vector([x,y,z]),
                cam.matrix_world * Vector([-x,y,z]),
                cam.matrix_world * Vector([-x,-y,z]),
                cam.matrix_world * Vector([x,-y,z]),
                ]
        faces = [ [0,1,2,3] ]

        mesh.from_pydata(verts, [], faces)

        obj = bpy.data.objects.new(name, mesh)

        scn.objects.link(obj)

def make_cubes(scn):
    r=10
    for x in range(-r,r,2):
        for y in range(-r,r,2):
            for z in range(-r,r,2):
                name = "cube at %d,%d,%d"%(x,y,z)
                obj = bpy.data.objects.get(name)
                if obj is None:
                    mesh = bpy.data.meshes['Cube']
                    obj = bpy.data.objects.new(name, mesh)
                    scn.objects.link(obj)
                    obj.location = (x,y,z)

def cubes(scn):
    return [ obj for obj in scn.objects if obj.name[:8]=='cube at ']

def visible_from_camera(cam_obj, loc):

    lens = cam_obj.data.lens
    ss = cam_obj.data.sensor_width

    v2 = cam_obj.matrix_world.inverted()*loc

    if v2.z >=0:
        return False

    x2 = v2.x / v2.z
    y2 = v2.y / v2.z

    w = ss/lens

    x3 = w/2
    y3 = w/2 * scn.render.resolution_y / scn.render.resolution_x

    print( "%f %f ;\t%f %f"%(x2, x3, y2, y3) )

    return abs(x2) <= x3 and abs(y2) <= y3

def adjust_visibility(scn):
    for obj in cubes(scn):
        obj.hide = visible_from_camera(scn.camera, obj.location)

#
#

scn = bpy.context.scene

make_cubes(scn)

create_planes(scn)

adjust_visibility(scn)