Python E.zfar方法代码示例

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import zfar [as 别名]
    def __init__(self, id, color, constant_att=None, linear_att=None, quad_att=None, zfar=None, xmlnode = None):
        """Create a new sun light.

        :param str id:
          A unique string identifier for the light
        :param tuple color:
          Either a tuple of size 3 containing the RGB color value
          of the light or a tuple of size 4 containing the RGBA
          color value of the light
        :param float constant_att:
          Constant attenuation factor
        :param float linear_att:
          Linear attenuation factor
        :param float quad_att:
          Quadratic attenuation factor
        :param float zfar:
          Distance to the far clipping plane
        :param xmlnode:
          If loaded from xml, the xml node

        """
        self.id = id
        """The unique string identifier for the light"""
        self.position = numpy.array( [0, 0, 0], dtype=numpy.float32 )
        #Not documenting this because it doesn't make sense to set the position
        # of an unbound light. The position isn't set until binding in a scene.
        self.color = color
        """Either a tuple of size 3 containing the RGB color value
          of the light or a tuple of size 4 containing the RGBA
          color value of the light"""
        self.constant_att = constant_att
        """Constant attenuation factor."""
        self.linear_att = linear_att
        """Linear attenuation factor."""
        self.quad_att = quad_att
        """Quadratic attenuation factor."""
        self.zfar = zfar
        """Distance to the far clipping plane"""
        
        if xmlnode != None:
            self.xmlnode = xmlnode
            """ElementTree representation of the light."""
        else:
            pnode = E.point(
                E.color(' '.join(map(str, self.color ) ))
            )
            if self.constant_att is not None:
                pnode.append(E.constant_attenuation(str(self.constant_att)))
            if self.linear_att is not None:
                pnode.append(E.linear_attenuation(str(self.linear_att)))
            if self.quad_att is not None:
                pnode.append(E.quadratic_attenuation(str(self.quad_att)))
            if self.zfar is not None:
                pnode.append(E.zfar(str(self.zvar)))
            
            self.xmlnode = E.light(
                E.technique_common(pnode)
            , id=self.id, name=self.id)

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import zfar [as 别名]
 def _recreateXmlNode(self):
     perspective_node = E.perspective()
     if self.xfov is not None:
         perspective_node.append(E.xfov(str(self.xfov)))
     if self.yfov is not None:
         perspective_node.append(E.yfov(str(self.yfov)))
     if self.aspect_ratio is not None:
         perspective_node.append(E.aspect_ratio(str(self.aspect_ratio)))
     perspective_node.append(E.znear(str(self.znear)))
     perspective_node.append(E.zfar(str(self.zfar)))
     self.xmlnode = E.camera(
         E.optics(
             E.technique_common(perspective_node)
         )
     , id=self.id, name=self.id)

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import zfar [as 别名]
    def __init__(self, id, fov, near, far, xmlnode = None):
        """Create a new camera.

        :Parameters:
          id
            Id for the object
          fov
            Y axis field of visiona in degrees
          near
            Near plane distance
          far
            Far plane distance
          xmlnode
            If load form xml, the xml node

        """
        self.id = id
        """Id in the camera library."""
        self.fov = fov
        """Field of vision in degrees."""
        self.near = near
        """Near plane distance."""
        self.far = far
        """Far plane distance."""
        self.position = numpy.array( [0, 0, 0], dtype=numpy.float32 )
        """Position in space of the point of view."""
        self.direction = numpy.array( [0, 0, -1], dtype=numpy.float32 )
        """Look direction of the camera."""
        self.up = numpy.array( [0, 1, 0], dtype=numpy.float32 )
        """Up vector of the camera."""
        if xmlnode != None: self.xmlnode = xmlnode
        else:
            self.xmlnode = E.camera(
                E.optics(
                    E.technique_common(
                        E.perspective(
                            E.yfov(str(self.fov)),
                            E.znear(str(self.near)),
                            E.zfar(str(self.far))
                        )
                    )
                )
            , id=self.id, name=self.id)

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import zfar [as 别名]
    def __init__(self, id, fov, near, far, xmlnode = None):
        """Create a new camera.

        :param str id:
          Id for the object
        :param float fov:
          Y axis field of vision in degrees
        :param float near:
          Near plane distance
        :param float far:
          Far plane distance
        :param xmlnode:
          If loaded from xml, the xml node

        """
        self.id = id
        """Id in the camera library."""
        self.fov = fov
        """Field of vision in degrees."""
        self.near = near
        """Near plane distance."""
        self.far = far
        """Far plane distance."""
        if xmlnode != None:
            self.xmlnode = xmlnode
            """ElementTree representation of the data."""
        else:
            self.xmlnode = E.camera(
                E.optics(
                    E.technique_common(
                        E.perspective(
                            E.yfov(str(self.fov)),
                            E.znear(str(self.near)),
                            E.zfar(str(self.far))
                        )
                    )
                )
            , id=self.id, name=self.id)