0001: //
0002: // This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.0 in JDK 1.6
0003: // See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a>
0004: // Any modifications to this file will be lost upon recompilation of the source schema.
0005: // Generated on: 2007.03.17 at 08:38:02 AM PDT
0006: //
0007:
0008: package org.collada.colladaschema;
0009:
0010: import java.util.ArrayList;
0011: import java.util.List;
0012: import javax.xml.bind.annotation.XmlAccessType;
0013: import javax.xml.bind.annotation.XmlAccessorType;
0014: import javax.xml.bind.annotation.XmlAttribute;
0015: import javax.xml.bind.annotation.XmlElement;
0016: import javax.xml.bind.annotation.XmlList;
0017: import javax.xml.bind.annotation.XmlType;
0018: import javax.xml.bind.annotation.adapters.CollapsedStringAdapter;
0019: import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
0020:
0021: /**
0022: *
0023: * Create a new, named param object in the CG Runtime, assign it a type, an initial value, and additional attributes at declaration time.
0024: *
0025: *
0026: * <p>Java class for cg_newparam complex type.
0027: *
0028: * <p>The following schema fragment specifies the expected content contained within this class.
0029: *
0030: * <pre>
0031: * <complexType name="cg_newparam">
0032: * <complexContent>
0033: * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
0034: * <sequence>
0035: * <element name="annotate" type="{http://www.collada.org/2005/11/COLLADASchema}fx_annotate_common" maxOccurs="unbounded" minOccurs="0"/>
0036: * <element name="semantic" type="{http://www.w3.org/2001/XMLSchema}NCName" minOccurs="0"/>
0037: * <element name="modifier" type="{http://www.collada.org/2005/11/COLLADASchema}fx_modifier_enum_common" minOccurs="0"/>
0038: * <choice>
0039: * <group ref="{http://www.collada.org/2005/11/COLLADASchema}cg_param_type"/>
0040: * <element name="usertype" type="{http://www.collada.org/2005/11/COLLADASchema}cg_setuser_type"/>
0041: * <element name="array" type="{http://www.collada.org/2005/11/COLLADASchema}cg_newarray_type"/>
0042: * </choice>
0043: * </sequence>
0044: * <attribute name="sid" use="required" type="{http://www.collada.org/2005/11/COLLADASchema}cg_identifier" />
0045: * </restriction>
0046: * </complexContent>
0047: * </complexType>
0048: * </pre>
0049: *
0050: *
0051: */
0052: @XmlAccessorType(XmlAccessType.FIELD)
0053: @XmlType(name="cg_newparam",propOrder={"annotates","semantic","modifier","half4X3","fixed1","int3X1","fixed2","fixed1X2","string","half4X4","half2X1","fixed3X3","fixed","surface","half4","fixed4","bool3X1","float2X3","fixed3X4","samplerDEPTH","bool1X3","float2X4","bool2","float3X4","bool2X3","half3X3","bool1","bool3","fixed2X2","half4X2","fixed4X4","bool2X4","bool","half3X4","int1","array","bool4X1","float2","samplerCUBE","half3X2","int2X1","bool3X4","float1X3","bool2X2","half1X2","half4X1","int3","sampler2D","half1X3","float4X4","half3X1","fixed2X4","float4X3","fixed1X4","int1X4","int4X3","bool2X1","fixed4X2","fixed3X2","half2X4","bool4X4","int4X2","float1X4","int4X4","bool4X3","float4","bool1X4","fixed1X3","half2","float3","bool1X1","float1X1","int1X3","int4","samplerRECT","usertype","half2X2","float2X2","half3","half1","bool4X2","half1X1","bool1X2","float4X2","fixed2X3","half","fixed4X1","_enum","_float","float3X1","int3X2","int3X4","fixed3","bool3X2","float3X2","int3X3","int1X1","_int","float1X2","half1X4","sampler1D","fixed1X1","int2","bool3X3","int1X2","int2X2","int4X1","bool4","fixed2X1","int2X4","fixed4X3","half2X3","float1","float4X1","int2X3","float2X1","fixed3X1","float3X3","sampler3D"})
0054: public class CgNewparam {
0055:
0056: @XmlElement(name="annotate")
0057: protected List<FxAnnotateCommon> annotates;
0058: @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
0059: protected String semantic;
0060: protected FxModifierEnumCommon modifier;
0061: @XmlList
0062: @XmlElement(name="half4x3",type=Float.class)
0063: protected List<Float> half4X3;
0064: protected Float fixed1;
0065: @XmlList
0066: @XmlElement(name="int3x1",type=Integer.class)
0067: protected List<Integer> int3X1;
0068: @XmlList
0069: @XmlElement(type=Float.class)
0070: protected List<Float> fixed2;
0071: @XmlList
0072: @XmlElement(name="fixed1x2",type=Float.class)
0073: protected List<Float> fixed1X2;
0074: protected String string;
0075: @XmlList
0076: @XmlElement(name="half4x4",type=Float.class)
0077: protected List<Float> half4X4;
0078: @XmlList
0079: @XmlElement(name="half2x1",type=Float.class)
0080: protected List<Float> half2X1;
0081: @XmlList
0082: @XmlElement(name="fixed3x3",type=Float.class)
0083: protected List<Float> fixed3X3;
0084: protected Float fixed;
0085: protected CgSurfaceType surface;
0086: @XmlList
0087: @XmlElement(type=Float.class)
0088: protected List<Float> half4;
0089: @XmlList
0090: @XmlElement(type=Float.class)
0091: protected List<Float> fixed4;
0092: @XmlList
0093: @XmlElement(name="bool3x1",type=Boolean.class)
0094: protected List<Boolean> bool3X1;
0095: @XmlList
0096: @XmlElement(name="float2x3",type=Float.class)
0097: protected List<Float> float2X3;
0098: @XmlList
0099: @XmlElement(name="fixed3x4",type=Float.class)
0100: protected List<Float> fixed3X4;
0101: protected CgSamplerDEPTH samplerDEPTH;
0102: @XmlList
0103: @XmlElement(name="bool1x3",type=Boolean.class)
0104: protected List<Boolean> bool1X3;
0105: @XmlList
0106: @XmlElement(name="float2x4",type=Float.class)
0107: protected List<Float> float2X4;
0108: @XmlList
0109: @XmlElement(type=Boolean.class)
0110: protected List<Boolean> bool2;
0111: @XmlList
0112: @XmlElement(name="float3x4",type=Float.class)
0113: protected List<Float> float3X4;
0114: @XmlList
0115: @XmlElement(name="bool2x3",type=Boolean.class)
0116: protected List<Boolean> bool2X3;
0117: @XmlList
0118: @XmlElement(name="half3x3",type=Float.class)
0119: protected List<Float> half3X3;
0120: protected Boolean bool1;
0121: @XmlList
0122: @XmlElement(type=Boolean.class)
0123: protected List<Boolean> bool3;
0124: @XmlList
0125: @XmlElement(name="fixed2x2",type=Float.class)
0126: protected List<Float> fixed2X2;
0127: @XmlList
0128: @XmlElement(name="half4x2",type=Float.class)
0129: protected List<Float> half4X2;
0130: @XmlList
0131: @XmlElement(name="fixed4x4",type=Float.class)
0132: protected List<Float> fixed4X4;
0133: @XmlList
0134: @XmlElement(name="bool2x4",type=Boolean.class)
0135: protected List<Boolean> bool2X4;
0136: protected Boolean bool;
0137: @XmlList
0138: @XmlElement(name="half3x4",type=Float.class)
0139: protected List<Float> half3X4;
0140: protected Integer int1;
0141: protected CgNewarrayType array;
0142: @XmlList
0143: @XmlElement(name="bool4x1",type=Boolean.class)
0144: protected List<Boolean> bool4X1;
0145: @XmlList
0146: @XmlElement(type=Float.class)
0147: protected List<Float> float2;
0148: protected CgSamplerCUBE samplerCUBE;
0149: @XmlList
0150: @XmlElement(name="half3x2",type=Float.class)
0151: protected List<Float> half3X2;
0152: @XmlList
0153: @XmlElement(name="int2x1",type=Integer.class)
0154: protected List<Integer> int2X1;
0155: @XmlList
0156: @XmlElement(name="bool3x4",type=Boolean.class)
0157: protected List<Boolean> bool3X4;
0158: @XmlList
0159: @XmlElement(name="float1x3",type=Float.class)
0160: protected List<Float> float1X3;
0161: @XmlList
0162: @XmlElement(name="bool2x2",type=Boolean.class)
0163: protected List<Boolean> bool2X2;
0164: @XmlList
0165: @XmlElement(name="half1x2",type=Float.class)
0166: protected List<Float> half1X2;
0167: @XmlList
0168: @XmlElement(name="half4x1",type=Float.class)
0169: protected List<Float> half4X1;
0170: @XmlList
0171: @XmlElement(type=Integer.class)
0172: protected List<Integer> int3;
0173: protected CgSampler2D sampler2D;
0174: @XmlList
0175: @XmlElement(name="half1x3",type=Float.class)
0176: protected List<Float> half1X3;
0177: @XmlList
0178: @XmlElement(name="float4x4",type=Float.class)
0179: protected List<Float> float4X4;
0180: @XmlList
0181: @XmlElement(name="half3x1",type=Float.class)
0182: protected List<Float> half3X1;
0183: @XmlList
0184: @XmlElement(name="fixed2x4",type=Float.class)
0185: protected List<Float> fixed2X4;
0186: @XmlList
0187: @XmlElement(name="float4x3",type=Float.class)
0188: protected List<Float> float4X3;
0189: @XmlList
0190: @XmlElement(name="fixed1x4",type=Float.class)
0191: protected List<Float> fixed1X4;
0192: @XmlList
0193: @XmlElement(name="int1x4",type=Integer.class)
0194: protected List<Integer> int1X4;
0195: @XmlList
0196: @XmlElement(name="int4x3",type=Integer.class)
0197: protected List<Integer> int4X3;
0198: @XmlList
0199: @XmlElement(name="bool2x1",type=Boolean.class)
0200: protected List<Boolean> bool2X1;
0201: @XmlList
0202: @XmlElement(name="fixed4x2",type=Float.class)
0203: protected List<Float> fixed4X2;
0204: @XmlList
0205: @XmlElement(name="fixed3x2",type=Float.class)
0206: protected List<Float> fixed3X2;
0207: @XmlList
0208: @XmlElement(name="half2x4",type=Float.class)
0209: protected List<Float> half2X4;
0210: @XmlList
0211: @XmlElement(name="bool4x4",type=Boolean.class)
0212: protected List<Boolean> bool4X4;
0213: @XmlList
0214: @XmlElement(name="int4x2",type=Integer.class)
0215: protected List<Integer> int4X2;
0216: @XmlList
0217: @XmlElement(name="float1x4",type=Float.class)
0218: protected List<Float> float1X4;
0219: @XmlList
0220: @XmlElement(name="int4x4",type=Integer.class)
0221: protected List<Integer> int4X4;
0222: @XmlList
0223: @XmlElement(name="bool4x3",type=Boolean.class)
0224: protected List<Boolean> bool4X3;
0225: @XmlList
0226: @XmlElement(type=Float.class)
0227: protected List<Float> float4;
0228: @XmlList
0229: @XmlElement(name="bool1x4",type=Boolean.class)
0230: protected List<Boolean> bool1X4;
0231: @XmlList
0232: @XmlElement(name="fixed1x3",type=Float.class)
0233: protected List<Float> fixed1X3;
0234: @XmlList
0235: @XmlElement(type=Float.class)
0236: protected List<Float> half2;
0237: @XmlList
0238: @XmlElement(type=Float.class)
0239: protected List<Float> float3;
0240: @XmlList
0241: @XmlElement(name="bool1x1",type=Boolean.class)
0242: protected List<Boolean> bool1X1;
0243: @XmlList
0244: @XmlElement(name="float1x1",type=Float.class)
0245: protected List<Float> float1X1;
0246: @XmlList
0247: @XmlElement(name="int1x3",type=Integer.class)
0248: protected List<Integer> int1X3;
0249: @XmlList
0250: @XmlElement(type=Integer.class)
0251: protected List<Integer> int4;
0252: protected CgSamplerRECT samplerRECT;
0253: protected CgSetuserType usertype;
0254: @XmlList
0255: @XmlElement(name="half2x2",type=Float.class)
0256: protected List<Float> half2X2;
0257: @XmlList
0258: @XmlElement(name="float2x2",type=Float.class)
0259: protected List<Float> float2X2;
0260: @XmlList
0261: @XmlElement(type=Float.class)
0262: protected List<Float> half3;
0263: protected Float half1;
0264: @XmlList
0265: @XmlElement(name="bool4x2",type=Boolean.class)
0266: protected List<Boolean> bool4X2;
0267: @XmlList
0268: @XmlElement(name="half1x1",type=Float.class)
0269: protected List<Float> half1X1;
0270: @XmlList
0271: @XmlElement(name="bool1x2",type=Boolean.class)
0272: protected List<Boolean> bool1X2;
0273: @XmlList
0274: @XmlElement(name="float4x2",type=Float.class)
0275: protected List<Float> float4X2;
0276: @XmlList
0277: @XmlElement(name="fixed2x3",type=Float.class)
0278: protected List<Float> fixed2X3;
0279: protected Float half;
0280: @XmlList
0281: @XmlElement(name="fixed4x1",type=Float.class)
0282: protected List<Float> fixed4X1;
0283: @XmlElement(name="enum")
0284: protected String _enum;
0285: @XmlElement(name="float")
0286: protected Float _float;
0287: @XmlList
0288: @XmlElement(name="float3x1",type=Float.class)
0289: protected List<Float> float3X1;
0290: @XmlList
0291: @XmlElement(name="int3x2",type=Integer.class)
0292: protected List<Integer> int3X2;
0293: @XmlList
0294: @XmlElement(name="int3x4",type=Integer.class)
0295: protected List<Integer> int3X4;
0296: @XmlList
0297: @XmlElement(type=Float.class)
0298: protected List<Float> fixed3;
0299: @XmlList
0300: @XmlElement(name="bool3x2",type=Boolean.class)
0301: protected List<Boolean> bool3X2;
0302: @XmlList
0303: @XmlElement(name="float3x2",type=Float.class)
0304: protected List<Float> float3X2;
0305: @XmlList
0306: @XmlElement(name="int3x3",type=Integer.class)
0307: protected List<Integer> int3X3;
0308: @XmlList
0309: @XmlElement(name="int1x1",type=Integer.class)
0310: protected List<Integer> int1X1;
0311: @XmlElement(name="int")
0312: protected Integer _int;
0313: @XmlList
0314: @XmlElement(name="float1x2",type=Float.class)
0315: protected List<Float> float1X2;
0316: @XmlList
0317: @XmlElement(name="half1x4",type=Float.class)
0318: protected List<Float> half1X4;
0319: protected CgSampler1D sampler1D;
0320: @XmlList
0321: @XmlElement(name="fixed1x1",type=Float.class)
0322: protected List<Float> fixed1X1;
0323: @XmlList
0324: @XmlElement(type=Integer.class)
0325: protected List<Integer> int2;
0326: @XmlList
0327: @XmlElement(name="bool3x3",type=Boolean.class)
0328: protected List<Boolean> bool3X3;
0329: @XmlList
0330: @XmlElement(name="int1x2",type=Integer.class)
0331: protected List<Integer> int1X2;
0332: @XmlList
0333: @XmlElement(name="int2x2",type=Integer.class)
0334: protected List<Integer> int2X2;
0335: @XmlList
0336: @XmlElement(name="int4x1",type=Integer.class)
0337: protected List<Integer> int4X1;
0338: @XmlList
0339: @XmlElement(type=Boolean.class)
0340: protected List<Boolean> bool4;
0341: @XmlList
0342: @XmlElement(name="fixed2x1",type=Float.class)
0343: protected List<Float> fixed2X1;
0344: @XmlList
0345: @XmlElement(name="int2x4",type=Integer.class)
0346: protected List<Integer> int2X4;
0347: @XmlList
0348: @XmlElement(name="fixed4x3",type=Float.class)
0349: protected List<Float> fixed4X3;
0350: @XmlList
0351: @XmlElement(name="half2x3",type=Float.class)
0352: protected List<Float> half2X3;
0353: protected Float float1;
0354: @XmlList
0355: @XmlElement(name="float4x1",type=Float.class)
0356: protected List<Float> float4X1;
0357: @XmlList
0358: @XmlElement(name="int2x3",type=Integer.class)
0359: protected List<Integer> int2X3;
0360: @XmlList
0361: @XmlElement(name="float2x1",type=Float.class)
0362: protected List<Float> float2X1;
0363: @XmlList
0364: @XmlElement(name="fixed3x1",type=Float.class)
0365: protected List<Float> fixed3X1;
0366: @XmlList
0367: @XmlElement(name="float3x3",type=Float.class)
0368: protected List<Float> float3X3;
0369: protected CgSampler3D sampler3D;
0370: @XmlAttribute(required=true)
0371: @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
0372: protected String sid;
0373:
0374: /**
0375: * Gets the value of the annotates property.
0376: *
0377: * <p>
0378: * This accessor method returns a reference to the live list,
0379: * not a snapshot. Therefore any modification you make to the
0380: * returned list will be present inside the JAXB object.
0381: * This is why there is not a <CODE>set</CODE> method for the annotates property.
0382: *
0383: * <p>
0384: * For example, to add a new item, do as follows:
0385: * <pre>
0386: * getAnnotates().add(newItem);
0387: * </pre>
0388: *
0389: *
0390: * <p>
0391: * Objects of the following type(s) are allowed in the list
0392: * {@link FxAnnotateCommon }
0393: *
0394: *
0395: */
0396: public List<FxAnnotateCommon> getAnnotates() {
0397: if (annotates == null) {
0398: annotates = new ArrayList<FxAnnotateCommon>();
0399: }
0400: return this .annotates;
0401: }
0402:
0403: /**
0404: * Gets the value of the semantic property.
0405: *
0406: * @return
0407: * possible object is
0408: * {@link String }
0409: *
0410: */
0411: public String getSemantic() {
0412: return semantic;
0413: }
0414:
0415: /**
0416: * Sets the value of the semantic property.
0417: *
0418: * @param value
0419: * allowed object is
0420: * {@link String }
0421: *
0422: */
0423: public void setSemantic(String value) {
0424: this .semantic = value;
0425: }
0426:
0427: /**
0428: * Gets the value of the modifier property.
0429: *
0430: * @return
0431: * possible object is
0432: * {@link FxModifierEnumCommon }
0433: *
0434: */
0435: public FxModifierEnumCommon getModifier() {
0436: return modifier;
0437: }
0438:
0439: /**
0440: * Sets the value of the modifier property.
0441: *
0442: * @param value
0443: * allowed object is
0444: * {@link FxModifierEnumCommon }
0445: *
0446: */
0447: public void setModifier(FxModifierEnumCommon value) {
0448: this .modifier = value;
0449: }
0450:
0451: /**
0452: * Gets the value of the half4X3 property.
0453: *
0454: * <p>
0455: * This accessor method returns a reference to the live list,
0456: * not a snapshot. Therefore any modification you make to the
0457: * returned list will be present inside the JAXB object.
0458: * This is why there is not a <CODE>set</CODE> method for the half4X3 property.
0459: *
0460: * <p>
0461: * For example, to add a new item, do as follows:
0462: * <pre>
0463: * getHalf4X3().add(newItem);
0464: * </pre>
0465: *
0466: *
0467: * <p>
0468: * Objects of the following type(s) are allowed in the list
0469: * {@link Float }
0470: *
0471: *
0472: */
0473: public List<Float> getHalf4X3() {
0474: if (half4X3 == null) {
0475: half4X3 = new ArrayList<Float>();
0476: }
0477: return this .half4X3;
0478: }
0479:
0480: /**
0481: * Gets the value of the fixed1 property.
0482: *
0483: * @return
0484: * possible object is
0485: * {@link Float }
0486: *
0487: */
0488: public Float getFixed1() {
0489: return fixed1;
0490: }
0491:
0492: /**
0493: * Sets the value of the fixed1 property.
0494: *
0495: * @param value
0496: * allowed object is
0497: * {@link Float }
0498: *
0499: */
0500: public void setFixed1(Float value) {
0501: this .fixed1 = value;
0502: }
0503:
0504: /**
0505: * Gets the value of the int3X1 property.
0506: *
0507: * <p>
0508: * This accessor method returns a reference to the live list,
0509: * not a snapshot. Therefore any modification you make to the
0510: * returned list will be present inside the JAXB object.
0511: * This is why there is not a <CODE>set</CODE> method for the int3X1 property.
0512: *
0513: * <p>
0514: * For example, to add a new item, do as follows:
0515: * <pre>
0516: * getInt3X1().add(newItem);
0517: * </pre>
0518: *
0519: *
0520: * <p>
0521: * Objects of the following type(s) are allowed in the list
0522: * {@link Integer }
0523: *
0524: *
0525: */
0526: public List<Integer> getInt3X1() {
0527: if (int3X1 == null) {
0528: int3X1 = new ArrayList<Integer>();
0529: }
0530: return this .int3X1;
0531: }
0532:
0533: /**
0534: * Gets the value of the fixed2 property.
0535: *
0536: * <p>
0537: * This accessor method returns a reference to the live list,
0538: * not a snapshot. Therefore any modification you make to the
0539: * returned list will be present inside the JAXB object.
0540: * This is why there is not a <CODE>set</CODE> method for the fixed2 property.
0541: *
0542: * <p>
0543: * For example, to add a new item, do as follows:
0544: * <pre>
0545: * getFixed2().add(newItem);
0546: * </pre>
0547: *
0548: *
0549: * <p>
0550: * Objects of the following type(s) are allowed in the list
0551: * {@link Float }
0552: *
0553: *
0554: */
0555: public List<Float> getFixed2() {
0556: if (fixed2 == null) {
0557: fixed2 = new ArrayList<Float>();
0558: }
0559: return this .fixed2;
0560: }
0561:
0562: /**
0563: * Gets the value of the fixed1X2 property.
0564: *
0565: * <p>
0566: * This accessor method returns a reference to the live list,
0567: * not a snapshot. Therefore any modification you make to the
0568: * returned list will be present inside the JAXB object.
0569: * This is why there is not a <CODE>set</CODE> method for the fixed1X2 property.
0570: *
0571: * <p>
0572: * For example, to add a new item, do as follows:
0573: * <pre>
0574: * getFixed1X2().add(newItem);
0575: * </pre>
0576: *
0577: *
0578: * <p>
0579: * Objects of the following type(s) are allowed in the list
0580: * {@link Float }
0581: *
0582: *
0583: */
0584: public List<Float> getFixed1X2() {
0585: if (fixed1X2 == null) {
0586: fixed1X2 = new ArrayList<Float>();
0587: }
0588: return this .fixed1X2;
0589: }
0590:
0591: /**
0592: * Gets the value of the string property.
0593: *
0594: * @return
0595: * possible object is
0596: * {@link String }
0597: *
0598: */
0599: public String getString() {
0600: return string;
0601: }
0602:
0603: /**
0604: * Sets the value of the string property.
0605: *
0606: * @param value
0607: * allowed object is
0608: * {@link String }
0609: *
0610: */
0611: public void setString(String value) {
0612: this .string = value;
0613: }
0614:
0615: /**
0616: * Gets the value of the half4X4 property.
0617: *
0618: * <p>
0619: * This accessor method returns a reference to the live list,
0620: * not a snapshot. Therefore any modification you make to the
0621: * returned list will be present inside the JAXB object.
0622: * This is why there is not a <CODE>set</CODE> method for the half4X4 property.
0623: *
0624: * <p>
0625: * For example, to add a new item, do as follows:
0626: * <pre>
0627: * getHalf4X4().add(newItem);
0628: * </pre>
0629: *
0630: *
0631: * <p>
0632: * Objects of the following type(s) are allowed in the list
0633: * {@link Float }
0634: *
0635: *
0636: */
0637: public List<Float> getHalf4X4() {
0638: if (half4X4 == null) {
0639: half4X4 = new ArrayList<Float>();
0640: }
0641: return this .half4X4;
0642: }
0643:
0644: /**
0645: * Gets the value of the half2X1 property.
0646: *
0647: * <p>
0648: * This accessor method returns a reference to the live list,
0649: * not a snapshot. Therefore any modification you make to the
0650: * returned list will be present inside the JAXB object.
0651: * This is why there is not a <CODE>set</CODE> method for the half2X1 property.
0652: *
0653: * <p>
0654: * For example, to add a new item, do as follows:
0655: * <pre>
0656: * getHalf2X1().add(newItem);
0657: * </pre>
0658: *
0659: *
0660: * <p>
0661: * Objects of the following type(s) are allowed in the list
0662: * {@link Float }
0663: *
0664: *
0665: */
0666: public List<Float> getHalf2X1() {
0667: if (half2X1 == null) {
0668: half2X1 = new ArrayList<Float>();
0669: }
0670: return this .half2X1;
0671: }
0672:
0673: /**
0674: * Gets the value of the fixed3X3 property.
0675: *
0676: * <p>
0677: * This accessor method returns a reference to the live list,
0678: * not a snapshot. Therefore any modification you make to the
0679: * returned list will be present inside the JAXB object.
0680: * This is why there is not a <CODE>set</CODE> method for the fixed3X3 property.
0681: *
0682: * <p>
0683: * For example, to add a new item, do as follows:
0684: * <pre>
0685: * getFixed3X3().add(newItem);
0686: * </pre>
0687: *
0688: *
0689: * <p>
0690: * Objects of the following type(s) are allowed in the list
0691: * {@link Float }
0692: *
0693: *
0694: */
0695: public List<Float> getFixed3X3() {
0696: if (fixed3X3 == null) {
0697: fixed3X3 = new ArrayList<Float>();
0698: }
0699: return this .fixed3X3;
0700: }
0701:
0702: /**
0703: * Gets the value of the fixed property.
0704: *
0705: * @return
0706: * possible object is
0707: * {@link Float }
0708: *
0709: */
0710: public Float getFixed() {
0711: return fixed;
0712: }
0713:
0714: /**
0715: * Sets the value of the fixed property.
0716: *
0717: * @param value
0718: * allowed object is
0719: * {@link Float }
0720: *
0721: */
0722: public void setFixed(Float value) {
0723: this .fixed = value;
0724: }
0725:
0726: /**
0727: * Gets the value of the surface property.
0728: *
0729: * @return
0730: * possible object is
0731: * {@link CgSurfaceType }
0732: *
0733: */
0734: public CgSurfaceType getSurface() {
0735: return surface;
0736: }
0737:
0738: /**
0739: * Sets the value of the surface property.
0740: *
0741: * @param value
0742: * allowed object is
0743: * {@link CgSurfaceType }
0744: *
0745: */
0746: public void setSurface(CgSurfaceType value) {
0747: this .surface = value;
0748: }
0749:
0750: /**
0751: * Gets the value of the half4 property.
0752: *
0753: * <p>
0754: * This accessor method returns a reference to the live list,
0755: * not a snapshot. Therefore any modification you make to the
0756: * returned list will be present inside the JAXB object.
0757: * This is why there is not a <CODE>set</CODE> method for the half4 property.
0758: *
0759: * <p>
0760: * For example, to add a new item, do as follows:
0761: * <pre>
0762: * getHalf4().add(newItem);
0763: * </pre>
0764: *
0765: *
0766: * <p>
0767: * Objects of the following type(s) are allowed in the list
0768: * {@link Float }
0769: *
0770: *
0771: */
0772: public List<Float> getHalf4() {
0773: if (half4 == null) {
0774: half4 = new ArrayList<Float>();
0775: }
0776: return this .half4;
0777: }
0778:
0779: /**
0780: * Gets the value of the fixed4 property.
0781: *
0782: * <p>
0783: * This accessor method returns a reference to the live list,
0784: * not a snapshot. Therefore any modification you make to the
0785: * returned list will be present inside the JAXB object.
0786: * This is why there is not a <CODE>set</CODE> method for the fixed4 property.
0787: *
0788: * <p>
0789: * For example, to add a new item, do as follows:
0790: * <pre>
0791: * getFixed4().add(newItem);
0792: * </pre>
0793: *
0794: *
0795: * <p>
0796: * Objects of the following type(s) are allowed in the list
0797: * {@link Float }
0798: *
0799: *
0800: */
0801: public List<Float> getFixed4() {
0802: if (fixed4 == null) {
0803: fixed4 = new ArrayList<Float>();
0804: }
0805: return this .fixed4;
0806: }
0807:
0808: /**
0809: * Gets the value of the bool3X1 property.
0810: *
0811: * <p>
0812: * This accessor method returns a reference to the live list,
0813: * not a snapshot. Therefore any modification you make to the
0814: * returned list will be present inside the JAXB object.
0815: * This is why there is not a <CODE>set</CODE> method for the bool3X1 property.
0816: *
0817: * <p>
0818: * For example, to add a new item, do as follows:
0819: * <pre>
0820: * getBool3X1().add(newItem);
0821: * </pre>
0822: *
0823: *
0824: * <p>
0825: * Objects of the following type(s) are allowed in the list
0826: * {@link Boolean }
0827: *
0828: *
0829: */
0830: public List<Boolean> getBool3X1() {
0831: if (bool3X1 == null) {
0832: bool3X1 = new ArrayList<Boolean>();
0833: }
0834: return this .bool3X1;
0835: }
0836:
0837: /**
0838: * Gets the value of the float2X3 property.
0839: *
0840: * <p>
0841: * This accessor method returns a reference to the live list,
0842: * not a snapshot. Therefore any modification you make to the
0843: * returned list will be present inside the JAXB object.
0844: * This is why there is not a <CODE>set</CODE> method for the float2X3 property.
0845: *
0846: * <p>
0847: * For example, to add a new item, do as follows:
0848: * <pre>
0849: * getFloat2X3().add(newItem);
0850: * </pre>
0851: *
0852: *
0853: * <p>
0854: * Objects of the following type(s) are allowed in the list
0855: * {@link Float }
0856: *
0857: *
0858: */
0859: public List<Float> getFloat2X3() {
0860: if (float2X3 == null) {
0861: float2X3 = new ArrayList<Float>();
0862: }
0863: return this .float2X3;
0864: }
0865:
0866: /**
0867: * Gets the value of the fixed3X4 property.
0868: *
0869: * <p>
0870: * This accessor method returns a reference to the live list,
0871: * not a snapshot. Therefore any modification you make to the
0872: * returned list will be present inside the JAXB object.
0873: * This is why there is not a <CODE>set</CODE> method for the fixed3X4 property.
0874: *
0875: * <p>
0876: * For example, to add a new item, do as follows:
0877: * <pre>
0878: * getFixed3X4().add(newItem);
0879: * </pre>
0880: *
0881: *
0882: * <p>
0883: * Objects of the following type(s) are allowed in the list
0884: * {@link Float }
0885: *
0886: *
0887: */
0888: public List<Float> getFixed3X4() {
0889: if (fixed3X4 == null) {
0890: fixed3X4 = new ArrayList<Float>();
0891: }
0892: return this .fixed3X4;
0893: }
0894:
0895: /**
0896: * Gets the value of the samplerDEPTH property.
0897: *
0898: * @return
0899: * possible object is
0900: * {@link CgSamplerDEPTH }
0901: *
0902: */
0903: public CgSamplerDEPTH getSamplerDEPTH() {
0904: return samplerDEPTH;
0905: }
0906:
0907: /**
0908: * Sets the value of the samplerDEPTH property.
0909: *
0910: * @param value
0911: * allowed object is
0912: * {@link CgSamplerDEPTH }
0913: *
0914: */
0915: public void setSamplerDEPTH(CgSamplerDEPTH value) {
0916: this .samplerDEPTH = value;
0917: }
0918:
0919: /**
0920: * Gets the value of the bool1X3 property.
0921: *
0922: * <p>
0923: * This accessor method returns a reference to the live list,
0924: * not a snapshot. Therefore any modification you make to the
0925: * returned list will be present inside the JAXB object.
0926: * This is why there is not a <CODE>set</CODE> method for the bool1X3 property.
0927: *
0928: * <p>
0929: * For example, to add a new item, do as follows:
0930: * <pre>
0931: * getBool1X3().add(newItem);
0932: * </pre>
0933: *
0934: *
0935: * <p>
0936: * Objects of the following type(s) are allowed in the list
0937: * {@link Boolean }
0938: *
0939: *
0940: */
0941: public List<Boolean> getBool1X3() {
0942: if (bool1X3 == null) {
0943: bool1X3 = new ArrayList<Boolean>();
0944: }
0945: return this .bool1X3;
0946: }
0947:
0948: /**
0949: * Gets the value of the float2X4 property.
0950: *
0951: * <p>
0952: * This accessor method returns a reference to the live list,
0953: * not a snapshot. Therefore any modification you make to the
0954: * returned list will be present inside the JAXB object.
0955: * This is why there is not a <CODE>set</CODE> method for the float2X4 property.
0956: *
0957: * <p>
0958: * For example, to add a new item, do as follows:
0959: * <pre>
0960: * getFloat2X4().add(newItem);
0961: * </pre>
0962: *
0963: *
0964: * <p>
0965: * Objects of the following type(s) are allowed in the list
0966: * {@link Float }
0967: *
0968: *
0969: */
0970: public List<Float> getFloat2X4() {
0971: if (float2X4 == null) {
0972: float2X4 = new ArrayList<Float>();
0973: }
0974: return this .float2X4;
0975: }
0976:
0977: /**
0978: * Gets the value of the bool2 property.
0979: *
0980: * <p>
0981: * This accessor method returns a reference to the live list,
0982: * not a snapshot. Therefore any modification you make to the
0983: * returned list will be present inside the JAXB object.
0984: * This is why there is not a <CODE>set</CODE> method for the bool2 property.
0985: *
0986: * <p>
0987: * For example, to add a new item, do as follows:
0988: * <pre>
0989: * getBool2().add(newItem);
0990: * </pre>
0991: *
0992: *
0993: * <p>
0994: * Objects of the following type(s) are allowed in the list
0995: * {@link Boolean }
0996: *
0997: *
0998: */
0999: public List<Boolean> getBool2() {
1000: if (bool2 == null) {
1001: bool2 = new ArrayList<Boolean>();
1002: }
1003: return this .bool2;
1004: }
1005:
1006: /**
1007: * Gets the value of the float3X4 property.
1008: *
1009: * <p>
1010: * This accessor method returns a reference to the live list,
1011: * not a snapshot. Therefore any modification you make to the
1012: * returned list will be present inside the JAXB object.
1013: * This is why there is not a <CODE>set</CODE> method for the float3X4 property.
1014: *
1015: * <p>
1016: * For example, to add a new item, do as follows:
1017: * <pre>
1018: * getFloat3X4().add(newItem);
1019: * </pre>
1020: *
1021: *
1022: * <p>
1023: * Objects of the following type(s) are allowed in the list
1024: * {@link Float }
1025: *
1026: *
1027: */
1028: public List<Float> getFloat3X4() {
1029: if (float3X4 == null) {
1030: float3X4 = new ArrayList<Float>();
1031: }
1032: return this .float3X4;
1033: }
1034:
1035: /**
1036: * Gets the value of the bool2X3 property.
1037: *
1038: * <p>
1039: * This accessor method returns a reference to the live list,
1040: * not a snapshot. Therefore any modification you make to the
1041: * returned list will be present inside the JAXB object.
1042: * This is why there is not a <CODE>set</CODE> method for the bool2X3 property.
1043: *
1044: * <p>
1045: * For example, to add a new item, do as follows:
1046: * <pre>
1047: * getBool2X3().add(newItem);
1048: * </pre>
1049: *
1050: *
1051: * <p>
1052: * Objects of the following type(s) are allowed in the list
1053: * {@link Boolean }
1054: *
1055: *
1056: */
1057: public List<Boolean> getBool2X3() {
1058: if (bool2X3 == null) {
1059: bool2X3 = new ArrayList<Boolean>();
1060: }
1061: return this .bool2X3;
1062: }
1063:
1064: /**
1065: * Gets the value of the half3X3 property.
1066: *
1067: * <p>
1068: * This accessor method returns a reference to the live list,
1069: * not a snapshot. Therefore any modification you make to the
1070: * returned list will be present inside the JAXB object.
1071: * This is why there is not a <CODE>set</CODE> method for the half3X3 property.
1072: *
1073: * <p>
1074: * For example, to add a new item, do as follows:
1075: * <pre>
1076: * getHalf3X3().add(newItem);
1077: * </pre>
1078: *
1079: *
1080: * <p>
1081: * Objects of the following type(s) are allowed in the list
1082: * {@link Float }
1083: *
1084: *
1085: */
1086: public List<Float> getHalf3X3() {
1087: if (half3X3 == null) {
1088: half3X3 = new ArrayList<Float>();
1089: }
1090: return this .half3X3;
1091: }
1092:
1093: /**
1094: * Gets the value of the bool1 property.
1095: *
1096: * @return
1097: * possible object is
1098: * {@link Boolean }
1099: *
1100: */
1101: public Boolean isBool1() {
1102: return bool1;
1103: }
1104:
1105: /**
1106: * Sets the value of the bool1 property.
1107: *
1108: * @param value
1109: * allowed object is
1110: * {@link Boolean }
1111: *
1112: */
1113: public void setBool1(Boolean value) {
1114: this .bool1 = value;
1115: }
1116:
1117: /**
1118: * Gets the value of the bool3 property.
1119: *
1120: * <p>
1121: * This accessor method returns a reference to the live list,
1122: * not a snapshot. Therefore any modification you make to the
1123: * returned list will be present inside the JAXB object.
1124: * This is why there is not a <CODE>set</CODE> method for the bool3 property.
1125: *
1126: * <p>
1127: * For example, to add a new item, do as follows:
1128: * <pre>
1129: * getBool3().add(newItem);
1130: * </pre>
1131: *
1132: *
1133: * <p>
1134: * Objects of the following type(s) are allowed in the list
1135: * {@link Boolean }
1136: *
1137: *
1138: */
1139: public List<Boolean> getBool3() {
1140: if (bool3 == null) {
1141: bool3 = new ArrayList<Boolean>();
1142: }
1143: return this .bool3;
1144: }
1145:
1146: /**
1147: * Gets the value of the fixed2X2 property.
1148: *
1149: * <p>
1150: * This accessor method returns a reference to the live list,
1151: * not a snapshot. Therefore any modification you make to the
1152: * returned list will be present inside the JAXB object.
1153: * This is why there is not a <CODE>set</CODE> method for the fixed2X2 property.
1154: *
1155: * <p>
1156: * For example, to add a new item, do as follows:
1157: * <pre>
1158: * getFixed2X2().add(newItem);
1159: * </pre>
1160: *
1161: *
1162: * <p>
1163: * Objects of the following type(s) are allowed in the list
1164: * {@link Float }
1165: *
1166: *
1167: */
1168: public List<Float> getFixed2X2() {
1169: if (fixed2X2 == null) {
1170: fixed2X2 = new ArrayList<Float>();
1171: }
1172: return this .fixed2X2;
1173: }
1174:
1175: /**
1176: * Gets the value of the half4X2 property.
1177: *
1178: * <p>
1179: * This accessor method returns a reference to the live list,
1180: * not a snapshot. Therefore any modification you make to the
1181: * returned list will be present inside the JAXB object.
1182: * This is why there is not a <CODE>set</CODE> method for the half4X2 property.
1183: *
1184: * <p>
1185: * For example, to add a new item, do as follows:
1186: * <pre>
1187: * getHalf4X2().add(newItem);
1188: * </pre>
1189: *
1190: *
1191: * <p>
1192: * Objects of the following type(s) are allowed in the list
1193: * {@link Float }
1194: *
1195: *
1196: */
1197: public List<Float> getHalf4X2() {
1198: if (half4X2 == null) {
1199: half4X2 = new ArrayList<Float>();
1200: }
1201: return this .half4X2;
1202: }
1203:
1204: /**
1205: * Gets the value of the fixed4X4 property.
1206: *
1207: * <p>
1208: * This accessor method returns a reference to the live list,
1209: * not a snapshot. Therefore any modification you make to the
1210: * returned list will be present inside the JAXB object.
1211: * This is why there is not a <CODE>set</CODE> method for the fixed4X4 property.
1212: *
1213: * <p>
1214: * For example, to add a new item, do as follows:
1215: * <pre>
1216: * getFixed4X4().add(newItem);
1217: * </pre>
1218: *
1219: *
1220: * <p>
1221: * Objects of the following type(s) are allowed in the list
1222: * {@link Float }
1223: *
1224: *
1225: */
1226: public List<Float> getFixed4X4() {
1227: if (fixed4X4 == null) {
1228: fixed4X4 = new ArrayList<Float>();
1229: }
1230: return this .fixed4X4;
1231: }
1232:
1233: /**
1234: * Gets the value of the bool2X4 property.
1235: *
1236: * <p>
1237: * This accessor method returns a reference to the live list,
1238: * not a snapshot. Therefore any modification you make to the
1239: * returned list will be present inside the JAXB object.
1240: * This is why there is not a <CODE>set</CODE> method for the bool2X4 property.
1241: *
1242: * <p>
1243: * For example, to add a new item, do as follows:
1244: * <pre>
1245: * getBool2X4().add(newItem);
1246: * </pre>
1247: *
1248: *
1249: * <p>
1250: * Objects of the following type(s) are allowed in the list
1251: * {@link Boolean }
1252: *
1253: *
1254: */
1255: public List<Boolean> getBool2X4() {
1256: if (bool2X4 == null) {
1257: bool2X4 = new ArrayList<Boolean>();
1258: }
1259: return this .bool2X4;
1260: }
1261:
1262: /**
1263: * Gets the value of the bool property.
1264: *
1265: * @return
1266: * possible object is
1267: * {@link Boolean }
1268: *
1269: */
1270: public Boolean isBool() {
1271: return bool;
1272: }
1273:
1274: /**
1275: * Sets the value of the bool property.
1276: *
1277: * @param value
1278: * allowed object is
1279: * {@link Boolean }
1280: *
1281: */
1282: public void setBool(Boolean value) {
1283: this .bool = value;
1284: }
1285:
1286: /**
1287: * Gets the value of the half3X4 property.
1288: *
1289: * <p>
1290: * This accessor method returns a reference to the live list,
1291: * not a snapshot. Therefore any modification you make to the
1292: * returned list will be present inside the JAXB object.
1293: * This is why there is not a <CODE>set</CODE> method for the half3X4 property.
1294: *
1295: * <p>
1296: * For example, to add a new item, do as follows:
1297: * <pre>
1298: * getHalf3X4().add(newItem);
1299: * </pre>
1300: *
1301: *
1302: * <p>
1303: * Objects of the following type(s) are allowed in the list
1304: * {@link Float }
1305: *
1306: *
1307: */
1308: public List<Float> getHalf3X4() {
1309: if (half3X4 == null) {
1310: half3X4 = new ArrayList<Float>();
1311: }
1312: return this .half3X4;
1313: }
1314:
1315: /**
1316: * Gets the value of the int1 property.
1317: *
1318: * @return
1319: * possible object is
1320: * {@link Integer }
1321: *
1322: */
1323: public Integer getInt1() {
1324: return int1;
1325: }
1326:
1327: /**
1328: * Sets the value of the int1 property.
1329: *
1330: * @param value
1331: * allowed object is
1332: * {@link Integer }
1333: *
1334: */
1335: public void setInt1(Integer value) {
1336: this .int1 = value;
1337: }
1338:
1339: /**
1340: * Gets the value of the array property.
1341: *
1342: * @return
1343: * possible object is
1344: * {@link CgNewarrayType }
1345: *
1346: */
1347: public CgNewarrayType getArray() {
1348: return array;
1349: }
1350:
1351: /**
1352: * Sets the value of the array property.
1353: *
1354: * @param value
1355: * allowed object is
1356: * {@link CgNewarrayType }
1357: *
1358: */
1359: public void setArray(CgNewarrayType value) {
1360: this .array = value;
1361: }
1362:
1363: /**
1364: * Gets the value of the bool4X1 property.
1365: *
1366: * <p>
1367: * This accessor method returns a reference to the live list,
1368: * not a snapshot. Therefore any modification you make to the
1369: * returned list will be present inside the JAXB object.
1370: * This is why there is not a <CODE>set</CODE> method for the bool4X1 property.
1371: *
1372: * <p>
1373: * For example, to add a new item, do as follows:
1374: * <pre>
1375: * getBool4X1().add(newItem);
1376: * </pre>
1377: *
1378: *
1379: * <p>
1380: * Objects of the following type(s) are allowed in the list
1381: * {@link Boolean }
1382: *
1383: *
1384: */
1385: public List<Boolean> getBool4X1() {
1386: if (bool4X1 == null) {
1387: bool4X1 = new ArrayList<Boolean>();
1388: }
1389: return this .bool4X1;
1390: }
1391:
1392: /**
1393: * Gets the value of the float2 property.
1394: *
1395: * <p>
1396: * This accessor method returns a reference to the live list,
1397: * not a snapshot. Therefore any modification you make to the
1398: * returned list will be present inside the JAXB object.
1399: * This is why there is not a <CODE>set</CODE> method for the float2 property.
1400: *
1401: * <p>
1402: * For example, to add a new item, do as follows:
1403: * <pre>
1404: * getFloat2().add(newItem);
1405: * </pre>
1406: *
1407: *
1408: * <p>
1409: * Objects of the following type(s) are allowed in the list
1410: * {@link Float }
1411: *
1412: *
1413: */
1414: public List<Float> getFloat2() {
1415: if (float2 == null) {
1416: float2 = new ArrayList<Float>();
1417: }
1418: return this .float2;
1419: }
1420:
1421: /**
1422: * Gets the value of the samplerCUBE property.
1423: *
1424: * @return
1425: * possible object is
1426: * {@link CgSamplerCUBE }
1427: *
1428: */
1429: public CgSamplerCUBE getSamplerCUBE() {
1430: return samplerCUBE;
1431: }
1432:
1433: /**
1434: * Sets the value of the samplerCUBE property.
1435: *
1436: * @param value
1437: * allowed object is
1438: * {@link CgSamplerCUBE }
1439: *
1440: */
1441: public void setSamplerCUBE(CgSamplerCUBE value) {
1442: this .samplerCUBE = value;
1443: }
1444:
1445: /**
1446: * Gets the value of the half3X2 property.
1447: *
1448: * <p>
1449: * This accessor method returns a reference to the live list,
1450: * not a snapshot. Therefore any modification you make to the
1451: * returned list will be present inside the JAXB object.
1452: * This is why there is not a <CODE>set</CODE> method for the half3X2 property.
1453: *
1454: * <p>
1455: * For example, to add a new item, do as follows:
1456: * <pre>
1457: * getHalf3X2().add(newItem);
1458: * </pre>
1459: *
1460: *
1461: * <p>
1462: * Objects of the following type(s) are allowed in the list
1463: * {@link Float }
1464: *
1465: *
1466: */
1467: public List<Float> getHalf3X2() {
1468: if (half3X2 == null) {
1469: half3X2 = new ArrayList<Float>();
1470: }
1471: return this .half3X2;
1472: }
1473:
1474: /**
1475: * Gets the value of the int2X1 property.
1476: *
1477: * <p>
1478: * This accessor method returns a reference to the live list,
1479: * not a snapshot. Therefore any modification you make to the
1480: * returned list will be present inside the JAXB object.
1481: * This is why there is not a <CODE>set</CODE> method for the int2X1 property.
1482: *
1483: * <p>
1484: * For example, to add a new item, do as follows:
1485: * <pre>
1486: * getInt2X1().add(newItem);
1487: * </pre>
1488: *
1489: *
1490: * <p>
1491: * Objects of the following type(s) are allowed in the list
1492: * {@link Integer }
1493: *
1494: *
1495: */
1496: public List<Integer> getInt2X1() {
1497: if (int2X1 == null) {
1498: int2X1 = new ArrayList<Integer>();
1499: }
1500: return this .int2X1;
1501: }
1502:
1503: /**
1504: * Gets the value of the bool3X4 property.
1505: *
1506: * <p>
1507: * This accessor method returns a reference to the live list,
1508: * not a snapshot. Therefore any modification you make to the
1509: * returned list will be present inside the JAXB object.
1510: * This is why there is not a <CODE>set</CODE> method for the bool3X4 property.
1511: *
1512: * <p>
1513: * For example, to add a new item, do as follows:
1514: * <pre>
1515: * getBool3X4().add(newItem);
1516: * </pre>
1517: *
1518: *
1519: * <p>
1520: * Objects of the following type(s) are allowed in the list
1521: * {@link Boolean }
1522: *
1523: *
1524: */
1525: public List<Boolean> getBool3X4() {
1526: if (bool3X4 == null) {
1527: bool3X4 = new ArrayList<Boolean>();
1528: }
1529: return this .bool3X4;
1530: }
1531:
1532: /**
1533: * Gets the value of the float1X3 property.
1534: *
1535: * <p>
1536: * This accessor method returns a reference to the live list,
1537: * not a snapshot. Therefore any modification you make to the
1538: * returned list will be present inside the JAXB object.
1539: * This is why there is not a <CODE>set</CODE> method for the float1X3 property.
1540: *
1541: * <p>
1542: * For example, to add a new item, do as follows:
1543: * <pre>
1544: * getFloat1X3().add(newItem);
1545: * </pre>
1546: *
1547: *
1548: * <p>
1549: * Objects of the following type(s) are allowed in the list
1550: * {@link Float }
1551: *
1552: *
1553: */
1554: public List<Float> getFloat1X3() {
1555: if (float1X3 == null) {
1556: float1X3 = new ArrayList<Float>();
1557: }
1558: return this .float1X3;
1559: }
1560:
1561: /**
1562: * Gets the value of the bool2X2 property.
1563: *
1564: * <p>
1565: * This accessor method returns a reference to the live list,
1566: * not a snapshot. Therefore any modification you make to the
1567: * returned list will be present inside the JAXB object.
1568: * This is why there is not a <CODE>set</CODE> method for the bool2X2 property.
1569: *
1570: * <p>
1571: * For example, to add a new item, do as follows:
1572: * <pre>
1573: * getBool2X2().add(newItem);
1574: * </pre>
1575: *
1576: *
1577: * <p>
1578: * Objects of the following type(s) are allowed in the list
1579: * {@link Boolean }
1580: *
1581: *
1582: */
1583: public List<Boolean> getBool2X2() {
1584: if (bool2X2 == null) {
1585: bool2X2 = new ArrayList<Boolean>();
1586: }
1587: return this .bool2X2;
1588: }
1589:
1590: /**
1591: * Gets the value of the half1X2 property.
1592: *
1593: * <p>
1594: * This accessor method returns a reference to the live list,
1595: * not a snapshot. Therefore any modification you make to the
1596: * returned list will be present inside the JAXB object.
1597: * This is why there is not a <CODE>set</CODE> method for the half1X2 property.
1598: *
1599: * <p>
1600: * For example, to add a new item, do as follows:
1601: * <pre>
1602: * getHalf1X2().add(newItem);
1603: * </pre>
1604: *
1605: *
1606: * <p>
1607: * Objects of the following type(s) are allowed in the list
1608: * {@link Float }
1609: *
1610: *
1611: */
1612: public List<Float> getHalf1X2() {
1613: if (half1X2 == null) {
1614: half1X2 = new ArrayList<Float>();
1615: }
1616: return this .half1X2;
1617: }
1618:
1619: /**
1620: * Gets the value of the half4X1 property.
1621: *
1622: * <p>
1623: * This accessor method returns a reference to the live list,
1624: * not a snapshot. Therefore any modification you make to the
1625: * returned list will be present inside the JAXB object.
1626: * This is why there is not a <CODE>set</CODE> method for the half4X1 property.
1627: *
1628: * <p>
1629: * For example, to add a new item, do as follows:
1630: * <pre>
1631: * getHalf4X1().add(newItem);
1632: * </pre>
1633: *
1634: *
1635: * <p>
1636: * Objects of the following type(s) are allowed in the list
1637: * {@link Float }
1638: *
1639: *
1640: */
1641: public List<Float> getHalf4X1() {
1642: if (half4X1 == null) {
1643: half4X1 = new ArrayList<Float>();
1644: }
1645: return this .half4X1;
1646: }
1647:
1648: /**
1649: * Gets the value of the int3 property.
1650: *
1651: * <p>
1652: * This accessor method returns a reference to the live list,
1653: * not a snapshot. Therefore any modification you make to the
1654: * returned list will be present inside the JAXB object.
1655: * This is why there is not a <CODE>set</CODE> method for the int3 property.
1656: *
1657: * <p>
1658: * For example, to add a new item, do as follows:
1659: * <pre>
1660: * getInt3().add(newItem);
1661: * </pre>
1662: *
1663: *
1664: * <p>
1665: * Objects of the following type(s) are allowed in the list
1666: * {@link Integer }
1667: *
1668: *
1669: */
1670: public List<Integer> getInt3() {
1671: if (int3 == null) {
1672: int3 = new ArrayList<Integer>();
1673: }
1674: return this .int3;
1675: }
1676:
1677: /**
1678: * Gets the value of the sampler2D property.
1679: *
1680: * @return
1681: * possible object is
1682: * {@link CgSampler2D }
1683: *
1684: */
1685: public CgSampler2D getSampler2D() {
1686: return sampler2D;
1687: }
1688:
1689: /**
1690: * Sets the value of the sampler2D property.
1691: *
1692: * @param value
1693: * allowed object is
1694: * {@link CgSampler2D }
1695: *
1696: */
1697: public void setSampler2D(CgSampler2D value) {
1698: this .sampler2D = value;
1699: }
1700:
1701: /**
1702: * Gets the value of the half1X3 property.
1703: *
1704: * <p>
1705: * This accessor method returns a reference to the live list,
1706: * not a snapshot. Therefore any modification you make to the
1707: * returned list will be present inside the JAXB object.
1708: * This is why there is not a <CODE>set</CODE> method for the half1X3 property.
1709: *
1710: * <p>
1711: * For example, to add a new item, do as follows:
1712: * <pre>
1713: * getHalf1X3().add(newItem);
1714: * </pre>
1715: *
1716: *
1717: * <p>
1718: * Objects of the following type(s) are allowed in the list
1719: * {@link Float }
1720: *
1721: *
1722: */
1723: public List<Float> getHalf1X3() {
1724: if (half1X3 == null) {
1725: half1X3 = new ArrayList<Float>();
1726: }
1727: return this .half1X3;
1728: }
1729:
1730: /**
1731: * Gets the value of the float4X4 property.
1732: *
1733: * <p>
1734: * This accessor method returns a reference to the live list,
1735: * not a snapshot. Therefore any modification you make to the
1736: * returned list will be present inside the JAXB object.
1737: * This is why there is not a <CODE>set</CODE> method for the float4X4 property.
1738: *
1739: * <p>
1740: * For example, to add a new item, do as follows:
1741: * <pre>
1742: * getFloat4X4().add(newItem);
1743: * </pre>
1744: *
1745: *
1746: * <p>
1747: * Objects of the following type(s) are allowed in the list
1748: * {@link Float }
1749: *
1750: *
1751: */
1752: public List<Float> getFloat4X4() {
1753: if (float4X4 == null) {
1754: float4X4 = new ArrayList<Float>();
1755: }
1756: return this .float4X4;
1757: }
1758:
1759: /**
1760: * Gets the value of the half3X1 property.
1761: *
1762: * <p>
1763: * This accessor method returns a reference to the live list,
1764: * not a snapshot. Therefore any modification you make to the
1765: * returned list will be present inside the JAXB object.
1766: * This is why there is not a <CODE>set</CODE> method for the half3X1 property.
1767: *
1768: * <p>
1769: * For example, to add a new item, do as follows:
1770: * <pre>
1771: * getHalf3X1().add(newItem);
1772: * </pre>
1773: *
1774: *
1775: * <p>
1776: * Objects of the following type(s) are allowed in the list
1777: * {@link Float }
1778: *
1779: *
1780: */
1781: public List<Float> getHalf3X1() {
1782: if (half3X1 == null) {
1783: half3X1 = new ArrayList<Float>();
1784: }
1785: return this .half3X1;
1786: }
1787:
1788: /**
1789: * Gets the value of the fixed2X4 property.
1790: *
1791: * <p>
1792: * This accessor method returns a reference to the live list,
1793: * not a snapshot. Therefore any modification you make to the
1794: * returned list will be present inside the JAXB object.
1795: * This is why there is not a <CODE>set</CODE> method for the fixed2X4 property.
1796: *
1797: * <p>
1798: * For example, to add a new item, do as follows:
1799: * <pre>
1800: * getFixed2X4().add(newItem);
1801: * </pre>
1802: *
1803: *
1804: * <p>
1805: * Objects of the following type(s) are allowed in the list
1806: * {@link Float }
1807: *
1808: *
1809: */
1810: public List<Float> getFixed2X4() {
1811: if (fixed2X4 == null) {
1812: fixed2X4 = new ArrayList<Float>();
1813: }
1814: return this .fixed2X4;
1815: }
1816:
1817: /**
1818: * Gets the value of the float4X3 property.
1819: *
1820: * <p>
1821: * This accessor method returns a reference to the live list,
1822: * not a snapshot. Therefore any modification you make to the
1823: * returned list will be present inside the JAXB object.
1824: * This is why there is not a <CODE>set</CODE> method for the float4X3 property.
1825: *
1826: * <p>
1827: * For example, to add a new item, do as follows:
1828: * <pre>
1829: * getFloat4X3().add(newItem);
1830: * </pre>
1831: *
1832: *
1833: * <p>
1834: * Objects of the following type(s) are allowed in the list
1835: * {@link Float }
1836: *
1837: *
1838: */
1839: public List<Float> getFloat4X3() {
1840: if (float4X3 == null) {
1841: float4X3 = new ArrayList<Float>();
1842: }
1843: return this .float4X3;
1844: }
1845:
1846: /**
1847: * Gets the value of the fixed1X4 property.
1848: *
1849: * <p>
1850: * This accessor method returns a reference to the live list,
1851: * not a snapshot. Therefore any modification you make to the
1852: * returned list will be present inside the JAXB object.
1853: * This is why there is not a <CODE>set</CODE> method for the fixed1X4 property.
1854: *
1855: * <p>
1856: * For example, to add a new item, do as follows:
1857: * <pre>
1858: * getFixed1X4().add(newItem);
1859: * </pre>
1860: *
1861: *
1862: * <p>
1863: * Objects of the following type(s) are allowed in the list
1864: * {@link Float }
1865: *
1866: *
1867: */
1868: public List<Float> getFixed1X4() {
1869: if (fixed1X4 == null) {
1870: fixed1X4 = new ArrayList<Float>();
1871: }
1872: return this .fixed1X4;
1873: }
1874:
1875: /**
1876: * Gets the value of the int1X4 property.
1877: *
1878: * <p>
1879: * This accessor method returns a reference to the live list,
1880: * not a snapshot. Therefore any modification you make to the
1881: * returned list will be present inside the JAXB object.
1882: * This is why there is not a <CODE>set</CODE> method for the int1X4 property.
1883: *
1884: * <p>
1885: * For example, to add a new item, do as follows:
1886: * <pre>
1887: * getInt1X4().add(newItem);
1888: * </pre>
1889: *
1890: *
1891: * <p>
1892: * Objects of the following type(s) are allowed in the list
1893: * {@link Integer }
1894: *
1895: *
1896: */
1897: public List<Integer> getInt1X4() {
1898: if (int1X4 == null) {
1899: int1X4 = new ArrayList<Integer>();
1900: }
1901: return this .int1X4;
1902: }
1903:
1904: /**
1905: * Gets the value of the int4X3 property.
1906: *
1907: * <p>
1908: * This accessor method returns a reference to the live list,
1909: * not a snapshot. Therefore any modification you make to the
1910: * returned list will be present inside the JAXB object.
1911: * This is why there is not a <CODE>set</CODE> method for the int4X3 property.
1912: *
1913: * <p>
1914: * For example, to add a new item, do as follows:
1915: * <pre>
1916: * getInt4X3().add(newItem);
1917: * </pre>
1918: *
1919: *
1920: * <p>
1921: * Objects of the following type(s) are allowed in the list
1922: * {@link Integer }
1923: *
1924: *
1925: */
1926: public List<Integer> getInt4X3() {
1927: if (int4X3 == null) {
1928: int4X3 = new ArrayList<Integer>();
1929: }
1930: return this .int4X3;
1931: }
1932:
1933: /**
1934: * Gets the value of the bool2X1 property.
1935: *
1936: * <p>
1937: * This accessor method returns a reference to the live list,
1938: * not a snapshot. Therefore any modification you make to the
1939: * returned list will be present inside the JAXB object.
1940: * This is why there is not a <CODE>set</CODE> method for the bool2X1 property.
1941: *
1942: * <p>
1943: * For example, to add a new item, do as follows:
1944: * <pre>
1945: * getBool2X1().add(newItem);
1946: * </pre>
1947: *
1948: *
1949: * <p>
1950: * Objects of the following type(s) are allowed in the list
1951: * {@link Boolean }
1952: *
1953: *
1954: */
1955: public List<Boolean> getBool2X1() {
1956: if (bool2X1 == null) {
1957: bool2X1 = new ArrayList<Boolean>();
1958: }
1959: return this .bool2X1;
1960: }
1961:
1962: /**
1963: * Gets the value of the fixed4X2 property.
1964: *
1965: * <p>
1966: * This accessor method returns a reference to the live list,
1967: * not a snapshot. Therefore any modification you make to the
1968: * returned list will be present inside the JAXB object.
1969: * This is why there is not a <CODE>set</CODE> method for the fixed4X2 property.
1970: *
1971: * <p>
1972: * For example, to add a new item, do as follows:
1973: * <pre>
1974: * getFixed4X2().add(newItem);
1975: * </pre>
1976: *
1977: *
1978: * <p>
1979: * Objects of the following type(s) are allowed in the list
1980: * {@link Float }
1981: *
1982: *
1983: */
1984: public List<Float> getFixed4X2() {
1985: if (fixed4X2 == null) {
1986: fixed4X2 = new ArrayList<Float>();
1987: }
1988: return this .fixed4X2;
1989: }
1990:
1991: /**
1992: * Gets the value of the fixed3X2 property.
1993: *
1994: * <p>
1995: * This accessor method returns a reference to the live list,
1996: * not a snapshot. Therefore any modification you make to the
1997: * returned list will be present inside the JAXB object.
1998: * This is why there is not a <CODE>set</CODE> method for the fixed3X2 property.
1999: *
2000: * <p>
2001: * For example, to add a new item, do as follows:
2002: * <pre>
2003: * getFixed3X2().add(newItem);
2004: * </pre>
2005: *
2006: *
2007: * <p>
2008: * Objects of the following type(s) are allowed in the list
2009: * {@link Float }
2010: *
2011: *
2012: */
2013: public List<Float> getFixed3X2() {
2014: if (fixed3X2 == null) {
2015: fixed3X2 = new ArrayList<Float>();
2016: }
2017: return this .fixed3X2;
2018: }
2019:
2020: /**
2021: * Gets the value of the half2X4 property.
2022: *
2023: * <p>
2024: * This accessor method returns a reference to the live list,
2025: * not a snapshot. Therefore any modification you make to the
2026: * returned list will be present inside the JAXB object.
2027: * This is why there is not a <CODE>set</CODE> method for the half2X4 property.
2028: *
2029: * <p>
2030: * For example, to add a new item, do as follows:
2031: * <pre>
2032: * getHalf2X4().add(newItem);
2033: * </pre>
2034: *
2035: *
2036: * <p>
2037: * Objects of the following type(s) are allowed in the list
2038: * {@link Float }
2039: *
2040: *
2041: */
2042: public List<Float> getHalf2X4() {
2043: if (half2X4 == null) {
2044: half2X4 = new ArrayList<Float>();
2045: }
2046: return this .half2X4;
2047: }
2048:
2049: /**
2050: * Gets the value of the bool4X4 property.
2051: *
2052: * <p>
2053: * This accessor method returns a reference to the live list,
2054: * not a snapshot. Therefore any modification you make to the
2055: * returned list will be present inside the JAXB object.
2056: * This is why there is not a <CODE>set</CODE> method for the bool4X4 property.
2057: *
2058: * <p>
2059: * For example, to add a new item, do as follows:
2060: * <pre>
2061: * getBool4X4().add(newItem);
2062: * </pre>
2063: *
2064: *
2065: * <p>
2066: * Objects of the following type(s) are allowed in the list
2067: * {@link Boolean }
2068: *
2069: *
2070: */
2071: public List<Boolean> getBool4X4() {
2072: if (bool4X4 == null) {
2073: bool4X4 = new ArrayList<Boolean>();
2074: }
2075: return this .bool4X4;
2076: }
2077:
2078: /**
2079: * Gets the value of the int4X2 property.
2080: *
2081: * <p>
2082: * This accessor method returns a reference to the live list,
2083: * not a snapshot. Therefore any modification you make to the
2084: * returned list will be present inside the JAXB object.
2085: * This is why there is not a <CODE>set</CODE> method for the int4X2 property.
2086: *
2087: * <p>
2088: * For example, to add a new item, do as follows:
2089: * <pre>
2090: * getInt4X2().add(newItem);
2091: * </pre>
2092: *
2093: *
2094: * <p>
2095: * Objects of the following type(s) are allowed in the list
2096: * {@link Integer }
2097: *
2098: *
2099: */
2100: public List<Integer> getInt4X2() {
2101: if (int4X2 == null) {
2102: int4X2 = new ArrayList<Integer>();
2103: }
2104: return this .int4X2;
2105: }
2106:
2107: /**
2108: * Gets the value of the float1X4 property.
2109: *
2110: * <p>
2111: * This accessor method returns a reference to the live list,
2112: * not a snapshot. Therefore any modification you make to the
2113: * returned list will be present inside the JAXB object.
2114: * This is why there is not a <CODE>set</CODE> method for the float1X4 property.
2115: *
2116: * <p>
2117: * For example, to add a new item, do as follows:
2118: * <pre>
2119: * getFloat1X4().add(newItem);
2120: * </pre>
2121: *
2122: *
2123: * <p>
2124: * Objects of the following type(s) are allowed in the list
2125: * {@link Float }
2126: *
2127: *
2128: */
2129: public List<Float> getFloat1X4() {
2130: if (float1X4 == null) {
2131: float1X4 = new ArrayList<Float>();
2132: }
2133: return this .float1X4;
2134: }
2135:
2136: /**
2137: * Gets the value of the int4X4 property.
2138: *
2139: * <p>
2140: * This accessor method returns a reference to the live list,
2141: * not a snapshot. Therefore any modification you make to the
2142: * returned list will be present inside the JAXB object.
2143: * This is why there is not a <CODE>set</CODE> method for the int4X4 property.
2144: *
2145: * <p>
2146: * For example, to add a new item, do as follows:
2147: * <pre>
2148: * getInt4X4().add(newItem);
2149: * </pre>
2150: *
2151: *
2152: * <p>
2153: * Objects of the following type(s) are allowed in the list
2154: * {@link Integer }
2155: *
2156: *
2157: */
2158: public List<Integer> getInt4X4() {
2159: if (int4X4 == null) {
2160: int4X4 = new ArrayList<Integer>();
2161: }
2162: return this .int4X4;
2163: }
2164:
2165: /**
2166: * Gets the value of the bool4X3 property.
2167: *
2168: * <p>
2169: * This accessor method returns a reference to the live list,
2170: * not a snapshot. Therefore any modification you make to the
2171: * returned list will be present inside the JAXB object.
2172: * This is why there is not a <CODE>set</CODE> method for the bool4X3 property.
2173: *
2174: * <p>
2175: * For example, to add a new item, do as follows:
2176: * <pre>
2177: * getBool4X3().add(newItem);
2178: * </pre>
2179: *
2180: *
2181: * <p>
2182: * Objects of the following type(s) are allowed in the list
2183: * {@link Boolean }
2184: *
2185: *
2186: */
2187: public List<Boolean> getBool4X3() {
2188: if (bool4X3 == null) {
2189: bool4X3 = new ArrayList<Boolean>();
2190: }
2191: return this .bool4X3;
2192: }
2193:
2194: /**
2195: * Gets the value of the float4 property.
2196: *
2197: * <p>
2198: * This accessor method returns a reference to the live list,
2199: * not a snapshot. Therefore any modification you make to the
2200: * returned list will be present inside the JAXB object.
2201: * This is why there is not a <CODE>set</CODE> method for the float4 property.
2202: *
2203: * <p>
2204: * For example, to add a new item, do as follows:
2205: * <pre>
2206: * getFloat4().add(newItem);
2207: * </pre>
2208: *
2209: *
2210: * <p>
2211: * Objects of the following type(s) are allowed in the list
2212: * {@link Float }
2213: *
2214: *
2215: */
2216: public List<Float> getFloat4() {
2217: if (float4 == null) {
2218: float4 = new ArrayList<Float>();
2219: }
2220: return this .float4;
2221: }
2222:
2223: /**
2224: * Gets the value of the bool1X4 property.
2225: *
2226: * <p>
2227: * This accessor method returns a reference to the live list,
2228: * not a snapshot. Therefore any modification you make to the
2229: * returned list will be present inside the JAXB object.
2230: * This is why there is not a <CODE>set</CODE> method for the bool1X4 property.
2231: *
2232: * <p>
2233: * For example, to add a new item, do as follows:
2234: * <pre>
2235: * getBool1X4().add(newItem);
2236: * </pre>
2237: *
2238: *
2239: * <p>
2240: * Objects of the following type(s) are allowed in the list
2241: * {@link Boolean }
2242: *
2243: *
2244: */
2245: public List<Boolean> getBool1X4() {
2246: if (bool1X4 == null) {
2247: bool1X4 = new ArrayList<Boolean>();
2248: }
2249: return this .bool1X4;
2250: }
2251:
2252: /**
2253: * Gets the value of the fixed1X3 property.
2254: *
2255: * <p>
2256: * This accessor method returns a reference to the live list,
2257: * not a snapshot. Therefore any modification you make to the
2258: * returned list will be present inside the JAXB object.
2259: * This is why there is not a <CODE>set</CODE> method for the fixed1X3 property.
2260: *
2261: * <p>
2262: * For example, to add a new item, do as follows:
2263: * <pre>
2264: * getFixed1X3().add(newItem);
2265: * </pre>
2266: *
2267: *
2268: * <p>
2269: * Objects of the following type(s) are allowed in the list
2270: * {@link Float }
2271: *
2272: *
2273: */
2274: public List<Float> getFixed1X3() {
2275: if (fixed1X3 == null) {
2276: fixed1X3 = new ArrayList<Float>();
2277: }
2278: return this .fixed1X3;
2279: }
2280:
2281: /**
2282: * Gets the value of the half2 property.
2283: *
2284: * <p>
2285: * This accessor method returns a reference to the live list,
2286: * not a snapshot. Therefore any modification you make to the
2287: * returned list will be present inside the JAXB object.
2288: * This is why there is not a <CODE>set</CODE> method for the half2 property.
2289: *
2290: * <p>
2291: * For example, to add a new item, do as follows:
2292: * <pre>
2293: * getHalf2().add(newItem);
2294: * </pre>
2295: *
2296: *
2297: * <p>
2298: * Objects of the following type(s) are allowed in the list
2299: * {@link Float }
2300: *
2301: *
2302: */
2303: public List<Float> getHalf2() {
2304: if (half2 == null) {
2305: half2 = new ArrayList<Float>();
2306: }
2307: return this .half2;
2308: }
2309:
2310: /**
2311: * Gets the value of the float3 property.
2312: *
2313: * <p>
2314: * This accessor method returns a reference to the live list,
2315: * not a snapshot. Therefore any modification you make to the
2316: * returned list will be present inside the JAXB object.
2317: * This is why there is not a <CODE>set</CODE> method for the float3 property.
2318: *
2319: * <p>
2320: * For example, to add a new item, do as follows:
2321: * <pre>
2322: * getFloat3().add(newItem);
2323: * </pre>
2324: *
2325: *
2326: * <p>
2327: * Objects of the following type(s) are allowed in the list
2328: * {@link Float }
2329: *
2330: *
2331: */
2332: public List<Float> getFloat3() {
2333: if (float3 == null) {
2334: float3 = new ArrayList<Float>();
2335: }
2336: return this .float3;
2337: }
2338:
2339: /**
2340: * Gets the value of the bool1X1 property.
2341: *
2342: * <p>
2343: * This accessor method returns a reference to the live list,
2344: * not a snapshot. Therefore any modification you make to the
2345: * returned list will be present inside the JAXB object.
2346: * This is why there is not a <CODE>set</CODE> method for the bool1X1 property.
2347: *
2348: * <p>
2349: * For example, to add a new item, do as follows:
2350: * <pre>
2351: * getBool1X1().add(newItem);
2352: * </pre>
2353: *
2354: *
2355: * <p>
2356: * Objects of the following type(s) are allowed in the list
2357: * {@link Boolean }
2358: *
2359: *
2360: */
2361: public List<Boolean> getBool1X1() {
2362: if (bool1X1 == null) {
2363: bool1X1 = new ArrayList<Boolean>();
2364: }
2365: return this .bool1X1;
2366: }
2367:
2368: /**
2369: * Gets the value of the float1X1 property.
2370: *
2371: * <p>
2372: * This accessor method returns a reference to the live list,
2373: * not a snapshot. Therefore any modification you make to the
2374: * returned list will be present inside the JAXB object.
2375: * This is why there is not a <CODE>set</CODE> method for the float1X1 property.
2376: *
2377: * <p>
2378: * For example, to add a new item, do as follows:
2379: * <pre>
2380: * getFloat1X1().add(newItem);
2381: * </pre>
2382: *
2383: *
2384: * <p>
2385: * Objects of the following type(s) are allowed in the list
2386: * {@link Float }
2387: *
2388: *
2389: */
2390: public List<Float> getFloat1X1() {
2391: if (float1X1 == null) {
2392: float1X1 = new ArrayList<Float>();
2393: }
2394: return this .float1X1;
2395: }
2396:
2397: /**
2398: * Gets the value of the int1X3 property.
2399: *
2400: * <p>
2401: * This accessor method returns a reference to the live list,
2402: * not a snapshot. Therefore any modification you make to the
2403: * returned list will be present inside the JAXB object.
2404: * This is why there is not a <CODE>set</CODE> method for the int1X3 property.
2405: *
2406: * <p>
2407: * For example, to add a new item, do as follows:
2408: * <pre>
2409: * getInt1X3().add(newItem);
2410: * </pre>
2411: *
2412: *
2413: * <p>
2414: * Objects of the following type(s) are allowed in the list
2415: * {@link Integer }
2416: *
2417: *
2418: */
2419: public List<Integer> getInt1X3() {
2420: if (int1X3 == null) {
2421: int1X3 = new ArrayList<Integer>();
2422: }
2423: return this .int1X3;
2424: }
2425:
2426: /**
2427: * Gets the value of the int4 property.
2428: *
2429: * <p>
2430: * This accessor method returns a reference to the live list,
2431: * not a snapshot. Therefore any modification you make to the
2432: * returned list will be present inside the JAXB object.
2433: * This is why there is not a <CODE>set</CODE> method for the int4 property.
2434: *
2435: * <p>
2436: * For example, to add a new item, do as follows:
2437: * <pre>
2438: * getInt4().add(newItem);
2439: * </pre>
2440: *
2441: *
2442: * <p>
2443: * Objects of the following type(s) are allowed in the list
2444: * {@link Integer }
2445: *
2446: *
2447: */
2448: public List<Integer> getInt4() {
2449: if (int4 == null) {
2450: int4 = new ArrayList<Integer>();
2451: }
2452: return this .int4;
2453: }
2454:
2455: /**
2456: * Gets the value of the samplerRECT property.
2457: *
2458: * @return
2459: * possible object is
2460: * {@link CgSamplerRECT }
2461: *
2462: */
2463: public CgSamplerRECT getSamplerRECT() {
2464: return samplerRECT;
2465: }
2466:
2467: /**
2468: * Sets the value of the samplerRECT property.
2469: *
2470: * @param value
2471: * allowed object is
2472: * {@link CgSamplerRECT }
2473: *
2474: */
2475: public void setSamplerRECT(CgSamplerRECT value) {
2476: this .samplerRECT = value;
2477: }
2478:
2479: /**
2480: * Gets the value of the usertype property.
2481: *
2482: * @return
2483: * possible object is
2484: * {@link CgSetuserType }
2485: *
2486: */
2487: public CgSetuserType getUsertype() {
2488: return usertype;
2489: }
2490:
2491: /**
2492: * Sets the value of the usertype property.
2493: *
2494: * @param value
2495: * allowed object is
2496: * {@link CgSetuserType }
2497: *
2498: */
2499: public void setUsertype(CgSetuserType value) {
2500: this .usertype = value;
2501: }
2502:
2503: /**
2504: * Gets the value of the half2X2 property.
2505: *
2506: * <p>
2507: * This accessor method returns a reference to the live list,
2508: * not a snapshot. Therefore any modification you make to the
2509: * returned list will be present inside the JAXB object.
2510: * This is why there is not a <CODE>set</CODE> method for the half2X2 property.
2511: *
2512: * <p>
2513: * For example, to add a new item, do as follows:
2514: * <pre>
2515: * getHalf2X2().add(newItem);
2516: * </pre>
2517: *
2518: *
2519: * <p>
2520: * Objects of the following type(s) are allowed in the list
2521: * {@link Float }
2522: *
2523: *
2524: */
2525: public List<Float> getHalf2X2() {
2526: if (half2X2 == null) {
2527: half2X2 = new ArrayList<Float>();
2528: }
2529: return this .half2X2;
2530: }
2531:
2532: /**
2533: * Gets the value of the float2X2 property.
2534: *
2535: * <p>
2536: * This accessor method returns a reference to the live list,
2537: * not a snapshot. Therefore any modification you make to the
2538: * returned list will be present inside the JAXB object.
2539: * This is why there is not a <CODE>set</CODE> method for the float2X2 property.
2540: *
2541: * <p>
2542: * For example, to add a new item, do as follows:
2543: * <pre>
2544: * getFloat2X2().add(newItem);
2545: * </pre>
2546: *
2547: *
2548: * <p>
2549: * Objects of the following type(s) are allowed in the list
2550: * {@link Float }
2551: *
2552: *
2553: */
2554: public List<Float> getFloat2X2() {
2555: if (float2X2 == null) {
2556: float2X2 = new ArrayList<Float>();
2557: }
2558: return this .float2X2;
2559: }
2560:
2561: /**
2562: * Gets the value of the half3 property.
2563: *
2564: * <p>
2565: * This accessor method returns a reference to the live list,
2566: * not a snapshot. Therefore any modification you make to the
2567: * returned list will be present inside the JAXB object.
2568: * This is why there is not a <CODE>set</CODE> method for the half3 property.
2569: *
2570: * <p>
2571: * For example, to add a new item, do as follows:
2572: * <pre>
2573: * getHalf3().add(newItem);
2574: * </pre>
2575: *
2576: *
2577: * <p>
2578: * Objects of the following type(s) are allowed in the list
2579: * {@link Float }
2580: *
2581: *
2582: */
2583: public List<Float> getHalf3() {
2584: if (half3 == null) {
2585: half3 = new ArrayList<Float>();
2586: }
2587: return this .half3;
2588: }
2589:
2590: /**
2591: * Gets the value of the half1 property.
2592: *
2593: * @return
2594: * possible object is
2595: * {@link Float }
2596: *
2597: */
2598: public Float getHalf1() {
2599: return half1;
2600: }
2601:
2602: /**
2603: * Sets the value of the half1 property.
2604: *
2605: * @param value
2606: * allowed object is
2607: * {@link Float }
2608: *
2609: */
2610: public void setHalf1(Float value) {
2611: this .half1 = value;
2612: }
2613:
2614: /**
2615: * Gets the value of the bool4X2 property.
2616: *
2617: * <p>
2618: * This accessor method returns a reference to the live list,
2619: * not a snapshot. Therefore any modification you make to the
2620: * returned list will be present inside the JAXB object.
2621: * This is why there is not a <CODE>set</CODE> method for the bool4X2 property.
2622: *
2623: * <p>
2624: * For example, to add a new item, do as follows:
2625: * <pre>
2626: * getBool4X2().add(newItem);
2627: * </pre>
2628: *
2629: *
2630: * <p>
2631: * Objects of the following type(s) are allowed in the list
2632: * {@link Boolean }
2633: *
2634: *
2635: */
2636: public List<Boolean> getBool4X2() {
2637: if (bool4X2 == null) {
2638: bool4X2 = new ArrayList<Boolean>();
2639: }
2640: return this .bool4X2;
2641: }
2642:
2643: /**
2644: * Gets the value of the half1X1 property.
2645: *
2646: * <p>
2647: * This accessor method returns a reference to the live list,
2648: * not a snapshot. Therefore any modification you make to the
2649: * returned list will be present inside the JAXB object.
2650: * This is why there is not a <CODE>set</CODE> method for the half1X1 property.
2651: *
2652: * <p>
2653: * For example, to add a new item, do as follows:
2654: * <pre>
2655: * getHalf1X1().add(newItem);
2656: * </pre>
2657: *
2658: *
2659: * <p>
2660: * Objects of the following type(s) are allowed in the list
2661: * {@link Float }
2662: *
2663: *
2664: */
2665: public List<Float> getHalf1X1() {
2666: if (half1X1 == null) {
2667: half1X1 = new ArrayList<Float>();
2668: }
2669: return this .half1X1;
2670: }
2671:
2672: /**
2673: * Gets the value of the bool1X2 property.
2674: *
2675: * <p>
2676: * This accessor method returns a reference to the live list,
2677: * not a snapshot. Therefore any modification you make to the
2678: * returned list will be present inside the JAXB object.
2679: * This is why there is not a <CODE>set</CODE> method for the bool1X2 property.
2680: *
2681: * <p>
2682: * For example, to add a new item, do as follows:
2683: * <pre>
2684: * getBool1X2().add(newItem);
2685: * </pre>
2686: *
2687: *
2688: * <p>
2689: * Objects of the following type(s) are allowed in the list
2690: * {@link Boolean }
2691: *
2692: *
2693: */
2694: public List<Boolean> getBool1X2() {
2695: if (bool1X2 == null) {
2696: bool1X2 = new ArrayList<Boolean>();
2697: }
2698: return this .bool1X2;
2699: }
2700:
2701: /**
2702: * Gets the value of the float4X2 property.
2703: *
2704: * <p>
2705: * This accessor method returns a reference to the live list,
2706: * not a snapshot. Therefore any modification you make to the
2707: * returned list will be present inside the JAXB object.
2708: * This is why there is not a <CODE>set</CODE> method for the float4X2 property.
2709: *
2710: * <p>
2711: * For example, to add a new item, do as follows:
2712: * <pre>
2713: * getFloat4X2().add(newItem);
2714: * </pre>
2715: *
2716: *
2717: * <p>
2718: * Objects of the following type(s) are allowed in the list
2719: * {@link Float }
2720: *
2721: *
2722: */
2723: public List<Float> getFloat4X2() {
2724: if (float4X2 == null) {
2725: float4X2 = new ArrayList<Float>();
2726: }
2727: return this .float4X2;
2728: }
2729:
2730: /**
2731: * Gets the value of the fixed2X3 property.
2732: *
2733: * <p>
2734: * This accessor method returns a reference to the live list,
2735: * not a snapshot. Therefore any modification you make to the
2736: * returned list will be present inside the JAXB object.
2737: * This is why there is not a <CODE>set</CODE> method for the fixed2X3 property.
2738: *
2739: * <p>
2740: * For example, to add a new item, do as follows:
2741: * <pre>
2742: * getFixed2X3().add(newItem);
2743: * </pre>
2744: *
2745: *
2746: * <p>
2747: * Objects of the following type(s) are allowed in the list
2748: * {@link Float }
2749: *
2750: *
2751: */
2752: public List<Float> getFixed2X3() {
2753: if (fixed2X3 == null) {
2754: fixed2X3 = new ArrayList<Float>();
2755: }
2756: return this .fixed2X3;
2757: }
2758:
2759: /**
2760: * Gets the value of the half property.
2761: *
2762: * @return
2763: * possible object is
2764: * {@link Float }
2765: *
2766: */
2767: public Float getHalf() {
2768: return half;
2769: }
2770:
2771: /**
2772: * Sets the value of the half property.
2773: *
2774: * @param value
2775: * allowed object is
2776: * {@link Float }
2777: *
2778: */
2779: public void setHalf(Float value) {
2780: this .half = value;
2781: }
2782:
2783: /**
2784: * Gets the value of the fixed4X1 property.
2785: *
2786: * <p>
2787: * This accessor method returns a reference to the live list,
2788: * not a snapshot. Therefore any modification you make to the
2789: * returned list will be present inside the JAXB object.
2790: * This is why there is not a <CODE>set</CODE> method for the fixed4X1 property.
2791: *
2792: * <p>
2793: * For example, to add a new item, do as follows:
2794: * <pre>
2795: * getFixed4X1().add(newItem);
2796: * </pre>
2797: *
2798: *
2799: * <p>
2800: * Objects of the following type(s) are allowed in the list
2801: * {@link Float }
2802: *
2803: *
2804: */
2805: public List<Float> getFixed4X1() {
2806: if (fixed4X1 == null) {
2807: fixed4X1 = new ArrayList<Float>();
2808: }
2809: return this .fixed4X1;
2810: }
2811:
2812: /**
2813: * Gets the value of the enum property.
2814: *
2815: * @return
2816: * possible object is
2817: * {@link String }
2818: *
2819: */
2820: public String getEnum() {
2821: return _enum;
2822: }
2823:
2824: /**
2825: * Sets the value of the enum property.
2826: *
2827: * @param value
2828: * allowed object is
2829: * {@link String }
2830: *
2831: */
2832: public void setEnum(String value) {
2833: this ._enum = value;
2834: }
2835:
2836: /**
2837: * Gets the value of the float property.
2838: *
2839: * @return
2840: * possible object is
2841: * {@link Float }
2842: *
2843: */
2844: public Float getFloat() {
2845: return _float;
2846: }
2847:
2848: /**
2849: * Sets the value of the float property.
2850: *
2851: * @param value
2852: * allowed object is
2853: * {@link Float }
2854: *
2855: */
2856: public void setFloat(Float value) {
2857: this ._float = value;
2858: }
2859:
2860: /**
2861: * Gets the value of the float3X1 property.
2862: *
2863: * <p>
2864: * This accessor method returns a reference to the live list,
2865: * not a snapshot. Therefore any modification you make to the
2866: * returned list will be present inside the JAXB object.
2867: * This is why there is not a <CODE>set</CODE> method for the float3X1 property.
2868: *
2869: * <p>
2870: * For example, to add a new item, do as follows:
2871: * <pre>
2872: * getFloat3X1().add(newItem);
2873: * </pre>
2874: *
2875: *
2876: * <p>
2877: * Objects of the following type(s) are allowed in the list
2878: * {@link Float }
2879: *
2880: *
2881: */
2882: public List<Float> getFloat3X1() {
2883: if (float3X1 == null) {
2884: float3X1 = new ArrayList<Float>();
2885: }
2886: return this .float3X1;
2887: }
2888:
2889: /**
2890: * Gets the value of the int3X2 property.
2891: *
2892: * <p>
2893: * This accessor method returns a reference to the live list,
2894: * not a snapshot. Therefore any modification you make to the
2895: * returned list will be present inside the JAXB object.
2896: * This is why there is not a <CODE>set</CODE> method for the int3X2 property.
2897: *
2898: * <p>
2899: * For example, to add a new item, do as follows:
2900: * <pre>
2901: * getInt3X2().add(newItem);
2902: * </pre>
2903: *
2904: *
2905: * <p>
2906: * Objects of the following type(s) are allowed in the list
2907: * {@link Integer }
2908: *
2909: *
2910: */
2911: public List<Integer> getInt3X2() {
2912: if (int3X2 == null) {
2913: int3X2 = new ArrayList<Integer>();
2914: }
2915: return this .int3X2;
2916: }
2917:
2918: /**
2919: * Gets the value of the int3X4 property.
2920: *
2921: * <p>
2922: * This accessor method returns a reference to the live list,
2923: * not a snapshot. Therefore any modification you make to the
2924: * returned list will be present inside the JAXB object.
2925: * This is why there is not a <CODE>set</CODE> method for the int3X4 property.
2926: *
2927: * <p>
2928: * For example, to add a new item, do as follows:
2929: * <pre>
2930: * getInt3X4().add(newItem);
2931: * </pre>
2932: *
2933: *
2934: * <p>
2935: * Objects of the following type(s) are allowed in the list
2936: * {@link Integer }
2937: *
2938: *
2939: */
2940: public List<Integer> getInt3X4() {
2941: if (int3X4 == null) {
2942: int3X4 = new ArrayList<Integer>();
2943: }
2944: return this .int3X4;
2945: }
2946:
2947: /**
2948: * Gets the value of the fixed3 property.
2949: *
2950: * <p>
2951: * This accessor method returns a reference to the live list,
2952: * not a snapshot. Therefore any modification you make to the
2953: * returned list will be present inside the JAXB object.
2954: * This is why there is not a <CODE>set</CODE> method for the fixed3 property.
2955: *
2956: * <p>
2957: * For example, to add a new item, do as follows:
2958: * <pre>
2959: * getFixed3().add(newItem);
2960: * </pre>
2961: *
2962: *
2963: * <p>
2964: * Objects of the following type(s) are allowed in the list
2965: * {@link Float }
2966: *
2967: *
2968: */
2969: public List<Float> getFixed3() {
2970: if (fixed3 == null) {
2971: fixed3 = new ArrayList<Float>();
2972: }
2973: return this .fixed3;
2974: }
2975:
2976: /**
2977: * Gets the value of the bool3X2 property.
2978: *
2979: * <p>
2980: * This accessor method returns a reference to the live list,
2981: * not a snapshot. Therefore any modification you make to the
2982: * returned list will be present inside the JAXB object.
2983: * This is why there is not a <CODE>set</CODE> method for the bool3X2 property.
2984: *
2985: * <p>
2986: * For example, to add a new item, do as follows:
2987: * <pre>
2988: * getBool3X2().add(newItem);
2989: * </pre>
2990: *
2991: *
2992: * <p>
2993: * Objects of the following type(s) are allowed in the list
2994: * {@link Boolean }
2995: *
2996: *
2997: */
2998: public List<Boolean> getBool3X2() {
2999: if (bool3X2 == null) {
3000: bool3X2 = new ArrayList<Boolean>();
3001: }
3002: return this .bool3X2;
3003: }
3004:
3005: /**
3006: * Gets the value of the float3X2 property.
3007: *
3008: * <p>
3009: * This accessor method returns a reference to the live list,
3010: * not a snapshot. Therefore any modification you make to the
3011: * returned list will be present inside the JAXB object.
3012: * This is why there is not a <CODE>set</CODE> method for the float3X2 property.
3013: *
3014: * <p>
3015: * For example, to add a new item, do as follows:
3016: * <pre>
3017: * getFloat3X2().add(newItem);
3018: * </pre>
3019: *
3020: *
3021: * <p>
3022: * Objects of the following type(s) are allowed in the list
3023: * {@link Float }
3024: *
3025: *
3026: */
3027: public List<Float> getFloat3X2() {
3028: if (float3X2 == null) {
3029: float3X2 = new ArrayList<Float>();
3030: }
3031: return this .float3X2;
3032: }
3033:
3034: /**
3035: * Gets the value of the int3X3 property.
3036: *
3037: * <p>
3038: * This accessor method returns a reference to the live list,
3039: * not a snapshot. Therefore any modification you make to the
3040: * returned list will be present inside the JAXB object.
3041: * This is why there is not a <CODE>set</CODE> method for the int3X3 property.
3042: *
3043: * <p>
3044: * For example, to add a new item, do as follows:
3045: * <pre>
3046: * getInt3X3().add(newItem);
3047: * </pre>
3048: *
3049: *
3050: * <p>
3051: * Objects of the following type(s) are allowed in the list
3052: * {@link Integer }
3053: *
3054: *
3055: */
3056: public List<Integer> getInt3X3() {
3057: if (int3X3 == null) {
3058: int3X3 = new ArrayList<Integer>();
3059: }
3060: return this .int3X3;
3061: }
3062:
3063: /**
3064: * Gets the value of the int1X1 property.
3065: *
3066: * <p>
3067: * This accessor method returns a reference to the live list,
3068: * not a snapshot. Therefore any modification you make to the
3069: * returned list will be present inside the JAXB object.
3070: * This is why there is not a <CODE>set</CODE> method for the int1X1 property.
3071: *
3072: * <p>
3073: * For example, to add a new item, do as follows:
3074: * <pre>
3075: * getInt1X1().add(newItem);
3076: * </pre>
3077: *
3078: *
3079: * <p>
3080: * Objects of the following type(s) are allowed in the list
3081: * {@link Integer }
3082: *
3083: *
3084: */
3085: public List<Integer> getInt1X1() {
3086: if (int1X1 == null) {
3087: int1X1 = new ArrayList<Integer>();
3088: }
3089: return this .int1X1;
3090: }
3091:
3092: /**
3093: * Gets the value of the int property.
3094: *
3095: * @return
3096: * possible object is
3097: * {@link Integer }
3098: *
3099: */
3100: public Integer getInt() {
3101: return _int;
3102: }
3103:
3104: /**
3105: * Sets the value of the int property.
3106: *
3107: * @param value
3108: * allowed object is
3109: * {@link Integer }
3110: *
3111: */
3112: public void setInt(Integer value) {
3113: this ._int = value;
3114: }
3115:
3116: /**
3117: * Gets the value of the float1X2 property.
3118: *
3119: * <p>
3120: * This accessor method returns a reference to the live list,
3121: * not a snapshot. Therefore any modification you make to the
3122: * returned list will be present inside the JAXB object.
3123: * This is why there is not a <CODE>set</CODE> method for the float1X2 property.
3124: *
3125: * <p>
3126: * For example, to add a new item, do as follows:
3127: * <pre>
3128: * getFloat1X2().add(newItem);
3129: * </pre>
3130: *
3131: *
3132: * <p>
3133: * Objects of the following type(s) are allowed in the list
3134: * {@link Float }
3135: *
3136: *
3137: */
3138: public List<Float> getFloat1X2() {
3139: if (float1X2 == null) {
3140: float1X2 = new ArrayList<Float>();
3141: }
3142: return this .float1X2;
3143: }
3144:
3145: /**
3146: * Gets the value of the half1X4 property.
3147: *
3148: * <p>
3149: * This accessor method returns a reference to the live list,
3150: * not a snapshot. Therefore any modification you make to the
3151: * returned list will be present inside the JAXB object.
3152: * This is why there is not a <CODE>set</CODE> method for the half1X4 property.
3153: *
3154: * <p>
3155: * For example, to add a new item, do as follows:
3156: * <pre>
3157: * getHalf1X4().add(newItem);
3158: * </pre>
3159: *
3160: *
3161: * <p>
3162: * Objects of the following type(s) are allowed in the list
3163: * {@link Float }
3164: *
3165: *
3166: */
3167: public List<Float> getHalf1X4() {
3168: if (half1X4 == null) {
3169: half1X4 = new ArrayList<Float>();
3170: }
3171: return this .half1X4;
3172: }
3173:
3174: /**
3175: * Gets the value of the sampler1D property.
3176: *
3177: * @return
3178: * possible object is
3179: * {@link CgSampler1D }
3180: *
3181: */
3182: public CgSampler1D getSampler1D() {
3183: return sampler1D;
3184: }
3185:
3186: /**
3187: * Sets the value of the sampler1D property.
3188: *
3189: * @param value
3190: * allowed object is
3191: * {@link CgSampler1D }
3192: *
3193: */
3194: public void setSampler1D(CgSampler1D value) {
3195: this .sampler1D = value;
3196: }
3197:
3198: /**
3199: * Gets the value of the fixed1X1 property.
3200: *
3201: * <p>
3202: * This accessor method returns a reference to the live list,
3203: * not a snapshot. Therefore any modification you make to the
3204: * returned list will be present inside the JAXB object.
3205: * This is why there is not a <CODE>set</CODE> method for the fixed1X1 property.
3206: *
3207: * <p>
3208: * For example, to add a new item, do as follows:
3209: * <pre>
3210: * getFixed1X1().add(newItem);
3211: * </pre>
3212: *
3213: *
3214: * <p>
3215: * Objects of the following type(s) are allowed in the list
3216: * {@link Float }
3217: *
3218: *
3219: */
3220: public List<Float> getFixed1X1() {
3221: if (fixed1X1 == null) {
3222: fixed1X1 = new ArrayList<Float>();
3223: }
3224: return this .fixed1X1;
3225: }
3226:
3227: /**
3228: * Gets the value of the int2 property.
3229: *
3230: * <p>
3231: * This accessor method returns a reference to the live list,
3232: * not a snapshot. Therefore any modification you make to the
3233: * returned list will be present inside the JAXB object.
3234: * This is why there is not a <CODE>set</CODE> method for the int2 property.
3235: *
3236: * <p>
3237: * For example, to add a new item, do as follows:
3238: * <pre>
3239: * getInt2().add(newItem);
3240: * </pre>
3241: *
3242: *
3243: * <p>
3244: * Objects of the following type(s) are allowed in the list
3245: * {@link Integer }
3246: *
3247: *
3248: */
3249: public List<Integer> getInt2() {
3250: if (int2 == null) {
3251: int2 = new ArrayList<Integer>();
3252: }
3253: return this .int2;
3254: }
3255:
3256: /**
3257: * Gets the value of the bool3X3 property.
3258: *
3259: * <p>
3260: * This accessor method returns a reference to the live list,
3261: * not a snapshot. Therefore any modification you make to the
3262: * returned list will be present inside the JAXB object.
3263: * This is why there is not a <CODE>set</CODE> method for the bool3X3 property.
3264: *
3265: * <p>
3266: * For example, to add a new item, do as follows:
3267: * <pre>
3268: * getBool3X3().add(newItem);
3269: * </pre>
3270: *
3271: *
3272: * <p>
3273: * Objects of the following type(s) are allowed in the list
3274: * {@link Boolean }
3275: *
3276: *
3277: */
3278: public List<Boolean> getBool3X3() {
3279: if (bool3X3 == null) {
3280: bool3X3 = new ArrayList<Boolean>();
3281: }
3282: return this .bool3X3;
3283: }
3284:
3285: /**
3286: * Gets the value of the int1X2 property.
3287: *
3288: * <p>
3289: * This accessor method returns a reference to the live list,
3290: * not a snapshot. Therefore any modification you make to the
3291: * returned list will be present inside the JAXB object.
3292: * This is why there is not a <CODE>set</CODE> method for the int1X2 property.
3293: *
3294: * <p>
3295: * For example, to add a new item, do as follows:
3296: * <pre>
3297: * getInt1X2().add(newItem);
3298: * </pre>
3299: *
3300: *
3301: * <p>
3302: * Objects of the following type(s) are allowed in the list
3303: * {@link Integer }
3304: *
3305: *
3306: */
3307: public List<Integer> getInt1X2() {
3308: if (int1X2 == null) {
3309: int1X2 = new ArrayList<Integer>();
3310: }
3311: return this .int1X2;
3312: }
3313:
3314: /**
3315: * Gets the value of the int2X2 property.
3316: *
3317: * <p>
3318: * This accessor method returns a reference to the live list,
3319: * not a snapshot. Therefore any modification you make to the
3320: * returned list will be present inside the JAXB object.
3321: * This is why there is not a <CODE>set</CODE> method for the int2X2 property.
3322: *
3323: * <p>
3324: * For example, to add a new item, do as follows:
3325: * <pre>
3326: * getInt2X2().add(newItem);
3327: * </pre>
3328: *
3329: *
3330: * <p>
3331: * Objects of the following type(s) are allowed in the list
3332: * {@link Integer }
3333: *
3334: *
3335: */
3336: public List<Integer> getInt2X2() {
3337: if (int2X2 == null) {
3338: int2X2 = new ArrayList<Integer>();
3339: }
3340: return this .int2X2;
3341: }
3342:
3343: /**
3344: * Gets the value of the int4X1 property.
3345: *
3346: * <p>
3347: * This accessor method returns a reference to the live list,
3348: * not a snapshot. Therefore any modification you make to the
3349: * returned list will be present inside the JAXB object.
3350: * This is why there is not a <CODE>set</CODE> method for the int4X1 property.
3351: *
3352: * <p>
3353: * For example, to add a new item, do as follows:
3354: * <pre>
3355: * getInt4X1().add(newItem);
3356: * </pre>
3357: *
3358: *
3359: * <p>
3360: * Objects of the following type(s) are allowed in the list
3361: * {@link Integer }
3362: *
3363: *
3364: */
3365: public List<Integer> getInt4X1() {
3366: if (int4X1 == null) {
3367: int4X1 = new ArrayList<Integer>();
3368: }
3369: return this .int4X1;
3370: }
3371:
3372: /**
3373: * Gets the value of the bool4 property.
3374: *
3375: * <p>
3376: * This accessor method returns a reference to the live list,
3377: * not a snapshot. Therefore any modification you make to the
3378: * returned list will be present inside the JAXB object.
3379: * This is why there is not a <CODE>set</CODE> method for the bool4 property.
3380: *
3381: * <p>
3382: * For example, to add a new item, do as follows:
3383: * <pre>
3384: * getBool4().add(newItem);
3385: * </pre>
3386: *
3387: *
3388: * <p>
3389: * Objects of the following type(s) are allowed in the list
3390: * {@link Boolean }
3391: *
3392: *
3393: */
3394: public List<Boolean> getBool4() {
3395: if (bool4 == null) {
3396: bool4 = new ArrayList<Boolean>();
3397: }
3398: return this .bool4;
3399: }
3400:
3401: /**
3402: * Gets the value of the fixed2X1 property.
3403: *
3404: * <p>
3405: * This accessor method returns a reference to the live list,
3406: * not a snapshot. Therefore any modification you make to the
3407: * returned list will be present inside the JAXB object.
3408: * This is why there is not a <CODE>set</CODE> method for the fixed2X1 property.
3409: *
3410: * <p>
3411: * For example, to add a new item, do as follows:
3412: * <pre>
3413: * getFixed2X1().add(newItem);
3414: * </pre>
3415: *
3416: *
3417: * <p>
3418: * Objects of the following type(s) are allowed in the list
3419: * {@link Float }
3420: *
3421: *
3422: */
3423: public List<Float> getFixed2X1() {
3424: if (fixed2X1 == null) {
3425: fixed2X1 = new ArrayList<Float>();
3426: }
3427: return this .fixed2X1;
3428: }
3429:
3430: /**
3431: * Gets the value of the int2X4 property.
3432: *
3433: * <p>
3434: * This accessor method returns a reference to the live list,
3435: * not a snapshot. Therefore any modification you make to the
3436: * returned list will be present inside the JAXB object.
3437: * This is why there is not a <CODE>set</CODE> method for the int2X4 property.
3438: *
3439: * <p>
3440: * For example, to add a new item, do as follows:
3441: * <pre>
3442: * getInt2X4().add(newItem);
3443: * </pre>
3444: *
3445: *
3446: * <p>
3447: * Objects of the following type(s) are allowed in the list
3448: * {@link Integer }
3449: *
3450: *
3451: */
3452: public List<Integer> getInt2X4() {
3453: if (int2X4 == null) {
3454: int2X4 = new ArrayList<Integer>();
3455: }
3456: return this .int2X4;
3457: }
3458:
3459: /**
3460: * Gets the value of the fixed4X3 property.
3461: *
3462: * <p>
3463: * This accessor method returns a reference to the live list,
3464: * not a snapshot. Therefore any modification you make to the
3465: * returned list will be present inside the JAXB object.
3466: * This is why there is not a <CODE>set</CODE> method for the fixed4X3 property.
3467: *
3468: * <p>
3469: * For example, to add a new item, do as follows:
3470: * <pre>
3471: * getFixed4X3().add(newItem);
3472: * </pre>
3473: *
3474: *
3475: * <p>
3476: * Objects of the following type(s) are allowed in the list
3477: * {@link Float }
3478: *
3479: *
3480: */
3481: public List<Float> getFixed4X3() {
3482: if (fixed4X3 == null) {
3483: fixed4X3 = new ArrayList<Float>();
3484: }
3485: return this .fixed4X3;
3486: }
3487:
3488: /**
3489: * Gets the value of the half2X3 property.
3490: *
3491: * <p>
3492: * This accessor method returns a reference to the live list,
3493: * not a snapshot. Therefore any modification you make to the
3494: * returned list will be present inside the JAXB object.
3495: * This is why there is not a <CODE>set</CODE> method for the half2X3 property.
3496: *
3497: * <p>
3498: * For example, to add a new item, do as follows:
3499: * <pre>
3500: * getHalf2X3().add(newItem);
3501: * </pre>
3502: *
3503: *
3504: * <p>
3505: * Objects of the following type(s) are allowed in the list
3506: * {@link Float }
3507: *
3508: *
3509: */
3510: public List<Float> getHalf2X3() {
3511: if (half2X3 == null) {
3512: half2X3 = new ArrayList<Float>();
3513: }
3514: return this .half2X3;
3515: }
3516:
3517: /**
3518: * Gets the value of the float1 property.
3519: *
3520: * @return
3521: * possible object is
3522: * {@link Float }
3523: *
3524: */
3525: public Float getFloat1() {
3526: return float1;
3527: }
3528:
3529: /**
3530: * Sets the value of the float1 property.
3531: *
3532: * @param value
3533: * allowed object is
3534: * {@link Float }
3535: *
3536: */
3537: public void setFloat1(Float value) {
3538: this .float1 = value;
3539: }
3540:
3541: /**
3542: * Gets the value of the float4X1 property.
3543: *
3544: * <p>
3545: * This accessor method returns a reference to the live list,
3546: * not a snapshot. Therefore any modification you make to the
3547: * returned list will be present inside the JAXB object.
3548: * This is why there is not a <CODE>set</CODE> method for the float4X1 property.
3549: *
3550: * <p>
3551: * For example, to add a new item, do as follows:
3552: * <pre>
3553: * getFloat4X1().add(newItem);
3554: * </pre>
3555: *
3556: *
3557: * <p>
3558: * Objects of the following type(s) are allowed in the list
3559: * {@link Float }
3560: *
3561: *
3562: */
3563: public List<Float> getFloat4X1() {
3564: if (float4X1 == null) {
3565: float4X1 = new ArrayList<Float>();
3566: }
3567: return this .float4X1;
3568: }
3569:
3570: /**
3571: * Gets the value of the int2X3 property.
3572: *
3573: * <p>
3574: * This accessor method returns a reference to the live list,
3575: * not a snapshot. Therefore any modification you make to the
3576: * returned list will be present inside the JAXB object.
3577: * This is why there is not a <CODE>set</CODE> method for the int2X3 property.
3578: *
3579: * <p>
3580: * For example, to add a new item, do as follows:
3581: * <pre>
3582: * getInt2X3().add(newItem);
3583: * </pre>
3584: *
3585: *
3586: * <p>
3587: * Objects of the following type(s) are allowed in the list
3588: * {@link Integer }
3589: *
3590: *
3591: */
3592: public List<Integer> getInt2X3() {
3593: if (int2X3 == null) {
3594: int2X3 = new ArrayList<Integer>();
3595: }
3596: return this .int2X3;
3597: }
3598:
3599: /**
3600: * Gets the value of the float2X1 property.
3601: *
3602: * <p>
3603: * This accessor method returns a reference to the live list,
3604: * not a snapshot. Therefore any modification you make to the
3605: * returned list will be present inside the JAXB object.
3606: * This is why there is not a <CODE>set</CODE> method for the float2X1 property.
3607: *
3608: * <p>
3609: * For example, to add a new item, do as follows:
3610: * <pre>
3611: * getFloat2X1().add(newItem);
3612: * </pre>
3613: *
3614: *
3615: * <p>
3616: * Objects of the following type(s) are allowed in the list
3617: * {@link Float }
3618: *
3619: *
3620: */
3621: public List<Float> getFloat2X1() {
3622: if (float2X1 == null) {
3623: float2X1 = new ArrayList<Float>();
3624: }
3625: return this .float2X1;
3626: }
3627:
3628: /**
3629: * Gets the value of the fixed3X1 property.
3630: *
3631: * <p>
3632: * This accessor method returns a reference to the live list,
3633: * not a snapshot. Therefore any modification you make to the
3634: * returned list will be present inside the JAXB object.
3635: * This is why there is not a <CODE>set</CODE> method for the fixed3X1 property.
3636: *
3637: * <p>
3638: * For example, to add a new item, do as follows:
3639: * <pre>
3640: * getFixed3X1().add(newItem);
3641: * </pre>
3642: *
3643: *
3644: * <p>
3645: * Objects of the following type(s) are allowed in the list
3646: * {@link Float }
3647: *
3648: *
3649: */
3650: public List<Float> getFixed3X1() {
3651: if (fixed3X1 == null) {
3652: fixed3X1 = new ArrayList<Float>();
3653: }
3654: return this .fixed3X1;
3655: }
3656:
3657: /**
3658: * Gets the value of the float3X3 property.
3659: *
3660: * <p>
3661: * This accessor method returns a reference to the live list,
3662: * not a snapshot. Therefore any modification you make to the
3663: * returned list will be present inside the JAXB object.
3664: * This is why there is not a <CODE>set</CODE> method for the float3X3 property.
3665: *
3666: * <p>
3667: * For example, to add a new item, do as follows:
3668: * <pre>
3669: * getFloat3X3().add(newItem);
3670: * </pre>
3671: *
3672: *
3673: * <p>
3674: * Objects of the following type(s) are allowed in the list
3675: * {@link Float }
3676: *
3677: *
3678: */
3679: public List<Float> getFloat3X3() {
3680: if (float3X3 == null) {
3681: float3X3 = new ArrayList<Float>();
3682: }
3683: return this .float3X3;
3684: }
3685:
3686: /**
3687: * Gets the value of the sampler3D property.
3688: *
3689: * @return
3690: * possible object is
3691: * {@link CgSampler3D }
3692: *
3693: */
3694: public CgSampler3D getSampler3D() {
3695: return sampler3D;
3696: }
3697:
3698: /**
3699: * Sets the value of the sampler3D property.
3700: *
3701: * @param value
3702: * allowed object is
3703: * {@link CgSampler3D }
3704: *
3705: */
3706: public void setSampler3D(CgSampler3D value) {
3707: this .sampler3D = value;
3708: }
3709:
3710: /**
3711: * Gets the value of the sid property.
3712: *
3713: * @return
3714: * possible object is
3715: * {@link String }
3716: *
3717: */
3718: public String getSid() {
3719: return sid;
3720: }
3721:
3722: /**
3723: * Sets the value of the sid property.
3724: *
3725: * @param value
3726: * allowed object is
3727: * {@link String }
3728: *
3729: */
3730: public void setSid(String value) {
3731: this.sid = value;
3732: }
3733:
3734: }
|