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