Source.cs :  » Game » RealmForge » ColladaNET » Import » C# / CSharp Open Source

using System;
using System.Xml;
using System.Collections;
using CDAColladaNET.Import.Attributes;

// Copyright (c) 2005 Accelerated Pictures, LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

namespace ColladaNET.Import{
  public class Source : NamedNode
  {
    #region Constants
    private static readonly string kFloat_Array = "dae:float_array";
    private static readonly string kInt_Array   = "dae:int_array";
    private static readonly string kBool_Array  = "dae:bool_array";
    private static readonly string kName_Array  = "dae:Name_array";
    private static readonly string kArray       = "dae:array"; // Q: Is this still in the spec?
    private static readonly string kTechniques  = "dae:technique";
    #endregion

    #region Enums
    public enum ESourceType { INT , FLOAT , BOOL };
    #endregion

    #region Accessors
    private CDA.TechniquesAttr mTechniques;
    public  CDA.TechniquesAttr Techniques { get { return mTechniques; } }
    #region TextValues
    private bool mbTextValues = false;
    private string [] mTextValues;
    public string [] TextValues 
    { 
      get 
      {
        if ( mbTextValues == false )
        {
          XmlNode node = XmlSource.SelectSingleNode( kFloat_Array , Collada.NS );
          if ( node == null )
          {
            node = XmlSource.SelectSingleNode( kInt_Array , Collada.NS );
          }
          if ( node == null )
          {
            node = XmlSource.SelectSingleNode( kBool_Array , Collada.NS );
          }
          if ( node == null )
          {
            node = XmlSource.SelectSingleNode( kName_Array , Collada.NS );
          }
          if ( node == null )
          {
            node = XmlSource.SelectSingleNode( kArray , Collada.NS );
          }
          string innerText = node.InnerText;
          string [] tokens = innerText.Split( kWhitespace );
          int nonNullTokenCount = 0;
          for ( int scanIndex = 0 ; scanIndex < tokens.Length ; scanIndex++ )
          {
            if ( tokens[scanIndex].Length > 0 )
            {
              nonNullTokenCount++;
            }
          }
          mTextValues = new string[nonNullTokenCount];
          int valueIndex = 0;
          for( int tokenIndex = 0 ; (tokenIndex < tokens.Length)&&(valueIndex < mTextValues.Length) ; tokenIndex++ )
          {
            string token = tokens[tokenIndex];
            if ( token.Length > 0 )
            {
              mTextValues[valueIndex++] = token;
            }
          }
          mbTextValues = true;
        }
        return mTextValues;
      } 
    }
    #endregion
    #region Floats
    private bool mbFloats = false;
    private float [] mFloats;
    public float [] Floats 
    { 
      get 
      {
        if ( mbFloats == false )
        {
          mFloats = new float[TextValues.Length];
          for( int valueIndex = 0 ; valueIndex < mFloats.Length ; valueIndex++ )
          {
            mFloats[valueIndex] = float.Parse( mTextValues[valueIndex] );
          }
          mbFloats = true;
        }
        return mFloats;
      } 
    }
    #endregion
    #region Ints
    private bool mbInts = false;
    private int [] mInts;
    public int [] Ints 
    { 
      get 
      {
        if ( mbInts == false )
        {
          mInts = new int[TextValues.Length];
          for( int valueIndex = 0 ; valueIndex < mInts.Length ; valueIndex++ )
          {
            mInts[valueIndex] = int.Parse( mTextValues[valueIndex] );
          }
          mbInts = true;
        }
        return mInts;
      } 
    }
    #endregion
    #region Bools
    private bool mbBools = false;
    private bool [] mBools;
    public bool [] Bools 
    { 
      get 
      {
        if ( mbBools == false )
        {
          mBools = new bool[TextValues.Length];
          for( int valueIndex = 0 ; valueIndex < mBools.Length ; valueIndex++ )
          {
            mBools[valueIndex] = bool.Parse( mTextValues[valueIndex] );
          }
          mbBools = true;
        }
        return mBools;
      } 
    }
    #endregion
    #endregion

    #region Constructors
    public Source( XmlNode source ) : base( source )
    {
      mTechniques = new CDA.TechniquesAttr( source , kTechniques );
    }
    #endregion
  }
}