Python E.technique_common方法代码示例

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import technique_common [as 别名]
    def __init__(self, id, color, xmlnode = None):
        """Create a new directional 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 xmlnode:
          If loaded from xml, the xml node

        """
        self.id = id
        """The unique string identifier for the light"""
        self.direction = numpy.array( [0, 0, -1], dtype=numpy.float32 )
        #Not documenting this because it doesn't make sense to set the direction
        # of an unbound light. The direction 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"""
        if xmlnode != None:
            self.xmlnode = xmlnode
            """ElementTree representation of the light."""
        else:
            self.xmlnode = E.light(
                E.technique_common(
                    E.directional(
                        E.color(' '.join(map(str, self.color)))
                    )
                )
            , id=self.id, name=self.id)

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

        :Parameters:
          id
            Id for the object
          color
            Light color
          xmlnode
            If load form xml, the xml node

        """
        self.id = id
        """Id in the light library."""
        # TODO: check if this is actually the initial direction
        self.direction = numpy.array([0, 0, 1], dtype=numpy.float32)
        """Incoming direction of the light."""
        self.color = color
        """Light color."""
        if xmlnode != None:
            self.xmlnode = xmlnode
        else:
            self.xmlnode = E.light(
                E.technique_common(E.directional(E.color(" ".join([str(v) for v in self.color])))),
                id=self.id,
                name=self.id,
            )

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import technique_common [as 别名]
    def save(self):
        """Saves the geometry node back to :attr:`xmlnode`"""
        self.xmlnode.set('url', "#%s" % self.geometry.id)
        
        for m in self.materials:
            m.save()
        
        matparent = self.xmlnode.find('%s/%s'%( tag('bind_material'), tag('technique_common') ) )
        if matparent is None and len(self.materials)==0:
            return
        elif matparent is None:
            matparent = E.technique_common()
            self.xmlnode.append(E.bind_material(matparent))
        elif len(self.materials) == 0 and matparent is not None:
            bindnode = self.xmlnode.find('%s' % tag('bind_material'))
            self.xmlnode.remove(bindnode)
            return

        for m in self.materials:
            if m.xmlnode not in matparent:
                matparent.append(m.xmlnode)
        xmlnodes = [m.xmlnode for m in self.materials]
        for n in matparent:
            if n not in xmlnodes:
                matparent.remove(n)

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import technique_common [as 别名]
    def __init__(self, geometry, materials=None, xmlnode=None):
        """Creates a geometry node

        :param collada.geometry.Geometry geometry:
          A geometry to instantiate in the scene
        :param list materials:
          A list containing items of type :class:`collada.scene.MaterialNode`.
          Each of these represents a material that the geometry should be
          bound to.
        :param xmlnode:
          When loaded, the xmlnode it comes from

        """
        self.geometry = geometry
        """An object of type :class:`collada.geometry.Geometry` representing the
        geometry to bind in the scene"""
        self.materials = []
        """A list containing items of type :class:`collada.scene.MaterialNode`.
          Each of these represents a material that the geometry is bound to."""
        if materials is not None:
            self.materials = materials
        if xmlnode != None:
            self.xmlnode = xmlnode
            """ElementTree representation of the geometry node."""
        else:
            self.xmlnode = E.instance_geometry(url="#%s" % self.geometry.id)
            if len(self.materials) > 0:
                self.xmlnode.append(E.bind_material(
                    E.technique_common(
                        *[mat.xmlnode for mat in self.materials]
                    )
                ))

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import technique_common [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 technique_common [as 别名]
    def __init__(self, id, data, components, xmlnode=None):
        """Create a name source instance.

        :param str id:
          A unique string identifier for the source
        :param numpy.array data:
          Numpy array (unshaped) with the source values
        :param tuple components:
          Tuple of strings describing the semantic of the data,
          e.g. ``('JOINT')`` would cause :attr:`data` to be
          reshaped as ``(-1, 1)``
        :param xmlnode:
          When loaded, the xmlnode it comes from.

        """
          
        self.id = id
        """The unique string identifier for the source"""
        self.data = data
        """Numpy array with the source values. This will be shaped as ``(-1,N)`` where ``N = len(self.components)``"""
        self.data.shape = (-1, len(components) )
        self.components = components
        """Tuple of strings describing the semantic of the data, e.g. ``('JOINT')``"""
        if xmlnode != None:
            self.xmlnode = xmlnode
            """ElementTree representation of the source."""
        else:
            self.data.shape = (-1,)
            txtdata = ' '.join(map(str, self.data.tolist() ))
            rawlen = len( self.data )
            self.data.shape = (-1, len(self.components) )
            acclen = len( self.data )
            stridelen = len(self.components)
            sourcename = "%s-array"%self.id
            
            self.xmlnode = E.source(
                E.Name_array(txtdata, count=str(rawlen), id=sourcename),
                E.technique_common(
                    E.accessor(
                        *[E.param(type='Name', name=c) for c in self.components]
                    , **{'count':str(acclen), 'stride':str(stridelen), 'source':sourcename})
                )
            , id=self.id )

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import technique_common [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 technique_common [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)

# 需要导入模块: from collada import E [as 别名]
# 或者: from collada.E import technique_common [as 别名]
    def __init__(
        self,
        id,
        color,
        constant_att=None,
        linear_att=None,
        quad_att=None,
        falloff_ang=None,
        falloff_exp=None,
        xmlnode=None,
    ):
        """Create a new spot 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 falloff_ang:
          Falloff angle
        :param float falloff_exp:
          Falloff exponent
        :param xmlnode:
          If loaded from xml, the xml node

        """
        self.id = id
        """The unique string identifier for the light"""
        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.falloff_ang = falloff_ang
        """Falloff angle"""
        self.falloff_exp = falloff_exp
        """Falloff exponent"""

        if xmlnode != None:
            self.xmlnode = xmlnode
            """ElementTree representation of the light."""
        else:
            pnode = E.spot(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.falloff_ang is not None:
                pnode.append(E.falloff_angle(str(self.falloff_ang)))
            if self.falloff_exp is not None:
                pnode.append(E.falloff_exponent(str(self.falloff_exp)))

            self.xmlnode = E.light(E.technique_common(pnode), id=self.id, name=self.id)