This file is indexed.

/usr/include/crystalspace-2.0/imap/ldrctxt.h is in libcrystalspace-dev 2.0+dfsg-1build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/*
    Copyright (C) 2002 by Jorrit Tyberghein

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_IMAP_LDRCTXT_H__
#define __CS_IMAP_LDRCTXT_H__

/**\file
 * Loader context
 */
#include "csutil/scf.h"

/**\addtogroup loadsave
 * @{ */
struct iCollection;
struct iGeneralMeshState;
struct iGeneralMeshSubMesh;
struct iMaterialWrapper;
struct iMeshFactoryWrapper;
struct iMeshWrapper;
struct iSector;
struct iTextureWrapper;
struct iLight;
struct iShader;
struct iObject;

/**
 * This interface gives the context for the loader.
 * It basically gives loading plugins a way to find materials,
 * meshes, and sectors. In all these cases region-qualified
 * names can be used (i.e. 'regionname/objectname') or normal
 * object names.
 * <p>
 * WARNING! When a context is created it should not be modified
 * afterwards. Some loader plugins will keep a reference to the
 * context when they support delayed loading. In that case they
 * still need the original contents in the context. So a loader
 * that creates a context should create a new one every time.
 */
struct iLoaderContext : public virtual iBase
{
  SCF_INTERFACE(iLoaderContext, 4, 2, 0);
  /// Find a sector.
  virtual iSector* FindSector (const char* name) = 0;
  
  /** Find a material.  If not found, try to use the filename supplied
   *  to find a matching texture.  If that isn't found, try to load
   *  the texture using the filename.  If loaded then it is also
   *  Prepared.
   */
  virtual iMaterialWrapper* FindMaterial (const char* filename, bool doLoad = true) = 0;

  /**
   * Same as FindMaterial but there is no assumption that the name
   * and the filename are the same.  This is useful if the filename
   * has /'s in it (a pathname), since region searching will mean that
   * names with /'s will never be found correctly.
   */
  virtual iMaterialWrapper* FindNamedMaterial (const char* name,
  	const char *filename) = 0;
  /// Find a mesh factory.
  virtual iMeshFactoryWrapper* FindMeshFactory (const char* name, bool notify = true) = 0;
  /// Find a mesh object.
  virtual iMeshWrapper* FindMeshObject (const char* name) = 0;
  
  /**
   * Find a texture.  If not found, attempt to load and prepare the
   * texture using the supplied filename as the name.
   */
  virtual iTextureWrapper* FindTexture (const char* filename, bool doLoad = true) = 0;

  /**
   * Find a texture with the given name.  If not found, attempt to load
   * the supplied filename and prepare the texture using the supplied name.
   */
  virtual iTextureWrapper* FindNamedTexture (const char* name,
  	const char *filename) = 0;

  /// Find a light
  virtual iLight* FindLight (const char* name) = 0;

  /**
   * Find a shader.
   * \remarks Implementations should treat shader names starting with a '*'
   *   in a special way: These are "built-in" shaders and should be searched 
   *   globally even if only the current collection is supposed to be looked
   *   up.
   */
  virtual iShader* FindShader (const char* name) = 0;

  /**
   * Return true if we check for dupes (to avoid objects with same name
   * being loaded again.
   */
  virtual bool CheckDupes () const = 0;

  /**
   * Return a collection if we only want to load in that collection.
   * 0 otherwise. If not 0 then all objects will be created in the collection.
   */
  virtual iCollection* GetCollection() const = 0;

  /**
   * Return true if we only want to look for objects in the region
   * given by GetRegion().
   */
  virtual bool CurrentCollectionOnly() const = 0;

  /**
   * Returns the flags to tell us what we want to keep.
   */
  virtual uint GetKeepFlags() const = 0;

  /**
   * Adds the object to the stored collection.
   */
  virtual void AddToCollection(iObject* obj) = 0;

  /**
   * Get the message verbosity.
   */
  virtual bool GetVerbose() = 0;
};

/** @} */

#endif // __CS_IMAP_LDRCTXT_H__