# Cone Primitive w/Texture Coords and Normals

A work in progress …

``````# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
#
# Author : Paul H. Leopard, DESE Research, Inc.
#
# Description:
#
#	Create and return a GeomNode describing an open shaded cone.
#
# Input(s):
#
#   nodeName - Name of the GeomNode
#   sliceCount - Number of slices in the cone.
#
# Output(s):
#
#	A GeomNode representing the cone
#
# Example Useage:
#
#   nodePath = NodePath(geomNode)
#   nodePath.reparentTo(render)
#

# Create points for a circle
deltaAngle = 360.0/float(sliceCount-2)
angle = 0
points = []
for i in range(0,sliceCount):
point = (x,y)
points.append(point)
angle += deltaAngle

# Define the vetex data format (GVF).
gvf = GeomVertexFormat.getV3n3c4t2()

# Create the vetex data container (GVD) using the GVF from above to
# describe its contents.
gvd = GeomVertexData('GridVertices',gvf,Geom.UHStatic)

# Create writers for the GVD, one for each type of data (column) that
# we are going to store in it.
gvwV = GeomVertexWriter(gvd,'vertex')
gvwT = GeomVertexWriter(gvd,'texcoord')
gvwC = GeomVertexWriter(gvd,'color')
gvwN = GeomVertexWriter(gvd,'normal')

# Use the writers to add vertex data to the GVD.
T = (0,0,1)
C = (1,1,1,1)
n = len(points)

# Upload Vertex/Normal/Tex/Color for top point
tIndex = 0

# For each point sample
for i in range(0,n):

# Get first point (A)
p = points[i]
A = (p[0],p[1],0)

# Get next point (B)
j = (i+1) % n
p = points[j]
B = (p[0],p[1],0)

# Compute surface normal (N0) for Facet(A,B,T)
x10 = B[0] - A[0]
y10 = B[1] - A[1]
z10 = B[2] - A[2]
x12 = B[0] - T[0]
y12 = B[1] - T[1]
z12 = B[2] - T[2]
cpx = (z10*y12) - (y10*z12)
cpy = (x10*z12) - (z10*x12)
cpz = (y10*x12) - (x10*y12)
r = math.sqrt(cpx*cpx + cpy*cpy + cpz*cpz)
N = (cpx/r, cpy/r, cpz/r)

# Get Previous point (C)
# Compute facet normal (N1) for C,A,T
# Compute average normal N = (N0 + N1)/2
# @TODO@ Implement these ^^^ later on

# Compute normalized texture coordinate TX(U,V) on XY plane
TX = (A[0],A[1])

# Create a GeomPrimitive object to use the vertices in the GVD
# then fill it with our cone facets data.

geom = Geom(gvd)

for i in range(0,n):

# Get first point (A)
aIndex = i+1

# Get next point (B)
j = (aIndex+1) % n
bIndex = j

# Create and upload face F(A,B,T)
tris = GeomTriangles(Geom.UHStatic)
tris.setIndexType(Geom.NTUint32)
tris.closePrimitive()

str = "\tTris : %d,%d,%d" % (aIndex,bIndex,tIndex)
print str

geomNode = GeomNode(nodeName)
return geomNode
``````

Version of the above in class form, derived from NodePath:

``````# Standard imports

import math

# Panda imports

from pandac.PandaModules import *

# PHL imports

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# Class name : EllipticalCone
#
# Description:
#
#	Extends NodePath to represent an elliptical cone with texture coordinates,
#   normals, and color coordinates.
#
# Author: Paul H. Leopard
#
# \$Modtime: 10/19/06 8:46p \$
#
# \$Revision: 2 \$
#
#-------0---------0---------0---------0---------0---------0---------0---------0
class EllipticalCone(NodePath):

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# Method name : __init__
#
# Description:
#
#	Create and return an instance of EllipticalCone.
#
# Input(s):
#
#   nodeName - Name of the GeomNode
#   sliceCount - Number of slices in the cone.
#
# Output(s):
#
#	A GeomNode representing the cone
#
def __init__(self,nodeName,sliceCount):