Beauty Salon α-BET (alphabet)

space001
Blender3d Collada dae modeling Use Papervision3d on Progression3 and 4 http://a-bet.secret.jp/#/access
more whaison works.
whaison space
space002
http://whaison.jugem.jp/ https://jp.pinterest.com/whaison/ https://www.instagram.com/whaison/ https://whaison.amebaownd.com/
https://suzuri.jp/whaison
http://whaison.blogspot.com/
http://whaison.tumblr.com/ http://qiita.com/users/whaison http://www.behance.net/whaison https://github.com/whaison/ https://bitbucket.org/whaison http://serato.com/user/whaison http://whaison.hatenablog.jp/

typo memo
http://d.hatena.ne.jp/whaison/


dayNote
http://www.myspace.com/whaison http://ameblo.jp/whaison/ http://blog.crooz.jp/whaison/ http://blog.crooz.jp/whaisoncafe/ http://nenpyo.org/whaison

fulldisk
http://full.shin-gen.jp/
http://whaison.client.jp/
http://www.dclog.jp/whaison/
featured forums.
space004
forum.unity3d.com/

forums.unrealengine.com.

Progression Forum.

FlashDevelop Forum.

Papervision3D Forum.

FlexUserGroup Forum.

SparkProjectForum.





Twitter







Mobile
qrcode
Calendar
SunMonTueWedThuFriSat
    123
45678910
11121314151617
18192021222324
252627282930 
<< November 2018 >>
New Entries
Archives
Categories
Recent comment
  • FlashDevelopでフォント埋め込み
    感謝!! (12/24)
  • cocos2d-x-3.0rc0 ,c++ ,cpp でTexturePacker で 吐き出した、plist と png でパラパラアニメーションのコード例
    whaison (04/17)
  • Blender2.67にbvh(web上に2500個以上ころがってる)入れてそのBoneオブジェクトをUnity4.0のmecanimで使う
    whaison (08/19)
  • Apple Dev Center 「Certificates, Identifiers & Profiles」で Adhoc をつくってXCode4.6.1でArchiveしてipaを書き出し
    whaison (04/30)
  • Flash CS6でプロパティーパネルで物理演算のジャンプの高さを設定できるCitrus Engine
    whaison (03/01)
  • 「Flash以外、例えばKinectとか」ON TOKYO (会場:高田馬場4-11-8 Floor 6階 ) 短縮URL http://bit.ly/dI0Bfx
    uka (03/02)
  • App Store Review Guidelines アップル社のアプリ審査基準ガイドライン和訳 Apple が 開発者を悩ませ ユーザーをハッピーにしたいガイドライン。w
    whaison (01/25)
  • Unity3d では ADOBE JAPAN OSAKIで行われたFITC 2010 TOKYOでは、 「iOS用にパブリッシュするためには、フリー版ではなくて、有料版を買ってください。さらに追加のパッケージである、"iOS Package (for Development)"を買ってください」とのことだった。
    whaison (01/25)
  • enjoy Adidas-Futsal-Park
    whaison (01/16)
  • MacBookAir にFlashPlayer入れたらなった。Mac Flash Player 10.1/10.2でUstream などでカメラが認識されないバグそんなときはUstreamProducer!でもなくiPhoneだと直ぐにライブ配信できた
    whaison (01/14)
simple sintax high lighter2.0
space003
SyntaxHighlighter2.0用 の貼り付けコード作成する!
Profile
Links
Recommend
Admin
無料ブログ作成サービス JUGEM
Seach this site
            
2018.03.23 Friday
world.h

 

 

 

 

T1(TYPE) struct ObjMap // Container for Game Objects, this is the same thing as 'Map', except without the control of manual adding new elements, which should be handled by 'WorldManager' (through 'WorldManager.objCreate')
{
   ObjMap& clear(); // remove all objects

   Int elms   ()C; // number of valid objects
   Int elmSize()C; // size   of       object (excluding the UID KEY)

   TYPE& operator[](Int i) ; // get i-th object
 C TYPE& operator[](Int i)C; // get i-th object

   Bool containsId (C UID  &obj_id)C; // if container contains       object with 'obj_id' ID
   Bool containsObj(C TYPE *obj   )C; // if container contains 'obj' object

   TYPE* find(C UID &obj_id); // find object by its ID, null on fail

   ObjMap& remove   (  Int   i     ); // remove i-th object from container
   ObjMap& removeId (C UID  &obj_id); // remove      object from container by its ID
   ObjMap& removeObj(C TYPE *data  ); // remove      object from container by its memory address

   // misc
   T1(BASE) operator   ObjMap&() ; // casting to container of 'BASE' objects, 'TYPE' must be extended from BASE
   T1(BASE) operator C ObjMap&()C; // casting to container of 'BASE' objects, 'TYPE' must be extended from BASE

   explicit ObjMap(Int block_elms=32);

private:
   Map _map;
};
/******************************************************************************/
enum WORLD_MODE // World Mode
{
   WORLD_STREAM, // streamed world (areas are loaded and unloaded depending on their distance to center of action inside 'WorldManager.update' method, those close to center of action are automatically loaded, those far away are unloaded, recommended for most games)
   WORLD_FULL  , // full     world (at start full world is loaded with all areas, may consume lots of memory, recommended for race games with fast travelling objects, where any loading pauses are unacceptable)
   WORLD_MANUAL, // manual   world (areas are not managed automatically, they can be loaded and unloaded only by manual use of 'WorldManager.areaSetState' method)
};
/******************************************************************************/
struct WorldSettings // World Settings
{
   EnvironmentPtr environment; // default environment settings for this world, defualt=null

   Flt   areaSize()C {return _area_size ;}   WorldSettings&   areaSize(Flt size); // get/set area size           , 0..Inf, default=32
   Int     hmRes ()C {return _hm_res    ;}   WorldSettings&     hmRes (Int res ); // get/set heightmap resolution, 2..129, default=65, setting resolution will automatically align the value to the "(nearest power of 2)+1"
   Int path2DRes ()C {return _path2d_res;}   WorldSettings& path2DRes (Int res ); // get/set 2d paths  resolution, 1..64 , default=32

   // operations
   WorldSettings& reset(); // reset to default values

   // io
   Bool save(File &f, CChar *path=null)C; // save to   file, 'path'=path at which resource is located (this is needed so that the sub-resources can be accessed with relative path), false on fail
   Bool load(File &f, CChar *path=null) ; // load from file, 'path'=path at which resource is located (this is needed so that the sub-resources can be accessed with relative path), false on fail

   Bool save(C Str &name)C; // save to   file, false on fail
   Bool load(C Str &name) ; // load from file, false on fail

   WorldSettings() {reset();}

private:
   Flt _area_size;
   Int _hm_res, _path2d_res;
};
/******************************************************************************/
struct WorldManager // World Manager
{
   static Bool update_objects_after_physics, // this specifies which should be updated first - objects or the physics, default=true (setting it to false may occur in lack of synchronization between the character mesh and its controller when using Physics.draw, false is required for synchronization of character physical clothing)
               use_background_loading      , // if enabled then nearby areas will be loaded to memory on a secondary thread, which will allow smooth travelling across big worlds without pauses for loading data, default=true (for Mobile platforms the default value is set to "Cpu.threads()>=2")
               use_early_z_for_terrain     , // if enable early-z rendering technique when drawing terrain, enabling early-z causes the terrain to be rendered additional time (to the depth buffer only), this has the cost of rendering the terrain additional time, however it can be beneficial if rendering will occlude other parts of the screen preventing from performing some pixel shader operations at later stage, whether this option should be enabled or disabled that depends on your world, and should be tested manually
               low_memory_usage            ; // if release resources every time they're not needed, enabling this may decrease memory usage however it will decrease loading times when loading areas/changing worlds, default=false

   MiniMap mini_map; // this is automatically managed by the World Manager, use it to access the maps for certain areas, however do not store references to returned images, because they may get deleted in 'WorldManager.update'

   Cipher *area_cipher; // pointer to custom Cipher object (default=null) used for encrypting area files in case they are stored as stdio files (if they are stored in paks, then this cipher is ignored)

   void (*link_references)(); // pointer to custom function (may be null) called when new objects have been loaded, and there is possibility that they should be linked with custom global 'Reference's, you can set this to a custom function and inside it manually call 'Reference.link' for all global 'Reference's (do not use this for 'Reference's stored inside 'Game.Obj' classes, as they should be linked inside 'Game.Obj.linkReferences' method)
   void (*physics_update )(); // pointer to custom function (may be null) called when frame physics simulation has ended. 'WorldManager.update' method automatically handles physics simulation updates. If 'physics_update' is not null then it will be called after 'Physics.stopSimulation' and before 'Physics.startSimulation'. This function can be useful when physics is being processed in a background thread, and you need to precisely access/modify actor parameters when the simulation is not being processed. For example, if physics simulation is processed in background thread (that processing could occur during entire frame) and on the main thread you wish to adjust actor velocities, then the simulation may not behave the same every time and may not be precise, due to the fact of adjusting actor parameters when the simulation is already running at unknown stage in background thread. To overcome this issue and gain ability of precise adjusting of actor values you can set this callback, which will be called when the simulation is at the moment not running in the background thread.

   // init
   T1(TYPE) WorldManager& setAreaClass(                                   ) { _grid.replaceClass(                                ); return T;} // set class responsible for areas    , TYPE must be extended from 'Game.Area'
   T1(TYPE) WorldManager& setAreaData (                                   ) {return _setAreaData(                                );          } // set class responsible for area data, TYPE must be extended from 'Game.Area.Data'
   T1(TYPE) WorldManager& setObjType  (ObjMap &obj_map, Int obj_type) {return _setObjType       (obj_map, obj_type, CType());          } // set memory container responsible for selected OBJ_TYPE

   // manage
   WorldManager& del   (                                                                  ); // manually delete current world
   Bool          NewTry(C Str  &world_name                                                ); // initialize new world from 'world_name' name   , false on fail
   Bool          NewTry(C UID  &world_id                                                  ); // initialize new world from 'world_id'   name id, false on fail
   WorldManager& New   (C Str  &world_name                                                ); // initialize new world from 'world_name' name   , Exit  on fail
   WorldManager& New   (C UID  &world_id                                                  ); // initialize new world from 'world_id'   name id, Exit  on fail
   Bool          load  (  File &f                                                         ); // load previously saved world state from 'f'         file, false on fail
   Bool          save  (  File &f                                                         ); // save active           world state to   'f'         file, false on fail
   Bool          load  (C Str  &save_name, Bool (*load)(File &f)=null, Cipher *cipher=null); // load previously saved world state from 'save_name' file, 'load'=pointer to fuction loading custom save data (it must return false on fail), false on fail
   Bool          save  (C Str  &save_name, Bool (*save)(File &f)=null, Cipher *cipher=null); // save active           world state to   'save_name' file, 'save'=pointer to fuction  saving custom save data (it must return false on fail), false on fail

   static void Create(C Str &world_name, C WorldSettings &settings); // create folders for empty game world so it can be loaded using 'New' method, and save its settings

   // get / set
   Bool           is           (               )C {return _name.is()          ;} // if  there is any world specified
 C UID&           id           (               )C {return _id                 ;} // get name id               of current world
 C Str&           name         (               )C {return _name               ;} // get name                  of current world
 C Str&           dataPath     (               )C {return _data_path          ;} // get data path             of current world
 C WorldSettings& settings     (               )C {return _settings           ;} // get settings              of current world
   Flt            areaSize     (               )C {return _settings.areaSize();} // get size of a single Area of current world
 C PathWorld&     path         (               )C {return _path               ;} // get path finder           of current world
   WORLD_MODE     mode         (               )C {return _mode               ;} // get manager mode, default=WORLD_STREAM
   WorldManager&  mode         (WORLD_MODE mode);                                // set manager mode, changing mode requires current world to be deleted first
   Flt            activeRange  (               )C {return _range              ;} // get World Active Range, default=100
   WorldManager&  activeRange  (Flt       range);                                // set World Active Range
   Flt            objUpdateTime(               )C {return _time_obj_update    ;} // get amount of CPU time which was needed to update all objects during last world update

   Vec2  areaToWorld(C VecI2 &xz  )C {return                                      xz*areaSize() ;} // convert Area  Coordinates to World Position in meters
   VecI2 worldToArea(C Vec2  &xz  )C {return                                Floor(xz/areaSize());} // convert World Position    to Area  Coordinates
   VecI2 worldToArea(C VecD2 &xz  )C {return                                Floor(xz/areaSize());} // convert World Position    to Area  Coordinates
   VecI2 worldToArea(C Vec   &pos )C {return                              worldToArea(pos .xz());} // convert World Position    to Area  Coordinates
   VecI2 worldToArea(C VecD  &pos )C {return                              worldToArea(pos .xz());} // convert World Position    to Area  Coordinates
   RectI worldToArea(C Rect  &rect)C {return RectI(worldToArea(rect.min), worldToArea(rect.max));} // convert World Position    to Area  Coordinates
   RectI worldToArea(C Box   &box )C {return RectI(worldToArea(box .min), worldToArea(box .max));} // convert World Position    to Area  Coordinates

   void setShader();

   // area
   struct AreaState
   {
      VecI2      xz   ; // xz coordinates of Area
      AREA_STATE state; // desired state  of Area

      void set(C VecI2 &xz, AREA_STATE state) {T.xz=xz; T.state=state;}

      AreaState(C VecI2 &xz=VecI2(0, 0), AREA_STATE state=AREA_UNLOADED) {set(xz, state);}
   };
   void  areaSetState (C MemPtr &area_states, Bool unload_remaining=false); // manually set the state of areas, this method can be used for WORLD_MANUAL (for other modes it is ignored), 'area_states'=list of area coordinates and their desired states, 'unload_remaining'=if automatically unload all areas that aren't included in the 'area_states' list
   Int   areaActiveNum(           )C; // get number of active areas
   Area* areaActive   (  Int    i )C; // get i-th      active area                         , if the index is out of range                                  then null is returned
   Area* areaActive   (C VecI2 &xz)C; // get           active area at 'xz' area coordinates, if the area doesn't exist or isn't active at that coordinates then null is returned (which means that only area with                          AREA_ACTIVE state can be returned)
   Area* areaLoaded   (C VecI2 &xz)C; // get           loaded area at 'xz' area coordinates, if the area doesn't exist or isn't loaded at that coordinates then null is returned (which means that only area with AREA_CACHE AREA_INACTIVE AREA_ACTIVE state can be returned)

   // heightmap
   Flt          hmHeight  (C Vec2 &xz, Bool smooth=true); // get world heightmap height   at 'xz' world 2D position,    0 on fail, this method is fast because it uses lookup table (Game.Area.Data.height      Image), see also 'Game.Area.hmHeight', 'smooth'=if calculate smooth value using linear interpolation
 C MaterialPtr& hmMaterial(C Vec2 &xz                  ); // get world heightmap material at 'xz' world 2D position, null on fail, this method is fast because it uses lookup table (Game.Area.Data.materialMap Image), see also 'Game.Area.hmMaterial'

   // water
 C WaterMtrlPtr& waterUnder(C Vec &pos, Flt *depth=null); // test if 'pos' world position is under water, 'depth'=optional parameter which can receive point under water depth if it is under water, if 'pos' is underwater then the method will return water material in which the position is located, if not underwater then null is returned

   Waypoint* findWaypoint(C Str &name) {return name.is   () ? Waypoints.get(dataPath()+"Waypoint/"+name              ) : null;} // find waypoint in this world, null on fail
   Waypoint* findWaypoint(C UID &id  ) {return id  .valid() ? Waypoints.get(dataPath()+"Waypoint/"+EncodeFileName(id)) : null;} // find waypoint in this world, null on fail
   Waypoint*  getWaypoint(C Str &name) {return name.is   () ? Waypoints    (dataPath()+"Waypoint/"+name              ) : null;} // get  waypoint in this world, Exit on fail
   Waypoint*  getWaypoint(C UID &id  ) {return id  .valid() ? Waypoints    (dataPath()+"Waypoint/"+EncodeFileName(id)) : null;} // get  waypoint in this world, Exit on fail

   // objects
   Obj* objCreateNear(              Object &object       , C Matrix &matrix, C UID *obj_id=null); // dynamically create object into world from 'object' object and desired matrix, 'matrix' scale will be used as objects scale, method fails    if 'matrix' is out of active range                                     , 'obj_id'=optional parameter specifying forcing custom object id for the object (the parameter can be useful if you've created an object on the server, and need to create it on client using the same id from the server, if the parameter is not specified then object id will be randomized), null  on fail
   Bool objCreate    (              Object &object       , C Matrix &matrix, C UID *obj_id=null); // dynamically create object into world from 'object' object and desired matrix, 'matrix' scale will be used as objects scale, method succeeds if 'matrix' is out of active range but pointer to object isn't returned, 'obj_id'=optional parameter specifying forcing custom object id for the object (the parameter can be useful if you've created an object on the server, and need to create it on client using the same id from the server, if the parameter is not specified then object id will be randomized), false on fail
   Bool objInject    (Int obj_type, File   &obj_save_data, C Vec    *pos                       ); // dynamically inject object into world from previously saved object data (using 'Game.Obj.save'), 'obj_type'=OBJ_TYPE, 'pos'=optional parameter to specify new position after loading the object (if null is passed then position will not be modified), false on fail

          Obj* moveWorldObjToStorage  (Obj &  world_obj, Memx &    storage                            ); // move   'world_obj' world   object into a custom 'storage' object container, this function will be performed only if   'world_obj' belongs to this world    and 'storage' is a container                   storing exactly the same type as the   'world_obj', if those conditions are met then the object will have its 'willBeMovedFromWorldToStorage' method called, then it will be removed from        world  and placed in the storage   , then it will have its 'memoryAddressChanged' method called followed by 'wasMovedFromWorldToStorage' and address of the object (now inside the     storage container) will be returned, if this method fails then null  is returned and no operation is performed
         Bool  moveStorageObjToWorld  (Obj &storage_obj, Memx &    storage, C Matrix  *obj_matrix=null); // move 'storage_obj' storage object into world                              , this function will be performed only if 'storage_obj' belongs to     'storage' and  world    is capable (see 'setObjType') of storing exactly the same type as the 'storage_obj', if those conditions are met then the object will have its 'willBeMovedFromStorageToWorld' method called, then it will be removed from      storage  and placed in the world     , then it will have its 'memoryAddressChanged' method called followed by 'wasMovedFromStorageToWorld' and true                                                         will be returned, if this method fails then false is returned and no operation is performed, 'obj_matrix'=optional parameter specifying new object matrix applied to the object when being moved to world (it's not applied if it's null or this method returned false)
   static Obj* MoveStorageObjToStorage(Obj &storage_obj, Memx &src_storage, Memx &dest_storage   ); // move 'storage_obj' storage object from 'src_storage' into 'dest_storage'  , this function will be performed only if 'storage_obj' belongs to 'src_storage' and 'storage' is a container                   storing exactly the same type as the 'storage_obj', if those conditions are met then the object                                                                      will be removed from 'src_storage' and placed in 'dest_storage', then it will have its 'memoryAddressChanged' method called                                          and address of the object (now inside the new storage container) will be returned, if this method fails then null  is returned and no operation is performed

   WorldManager& objGetAdd(MemPtr objects, C Ball    &ball   , Int obj_type=-1);                                                                 // get pointers to objects which position (Game.Obj.pos) is inside 'ball'   , process only objects with 'obj_type' OBJ_TYPE (-1=process all types), this function does not clear 'objects' container at start which means that objects are added to the container
   WorldManager& objGetAdd(MemPtr objects, C Capsule &capsule, Int obj_type=-1);                                                                 // get pointers to objects which position (Game.Obj.pos) is inside 'capsule', process only objects with 'obj_type' OBJ_TYPE (-1=process all types), this function does not clear 'objects' container at start which means that objects are added to the container
   WorldManager& objGetAdd(MemPtr objects, C Box     &box    , Int obj_type=-1);                                                                 // get pointers to objects which position (Game.Obj.pos) is inside 'box'    , process only objects with 'obj_type' OBJ_TYPE (-1=process all types), this function does not clear 'objects' container at start which means that objects are added to the container
   WorldManager& objGetAdd(MemPtr objects, C OBox    &obox   , Int obj_type=-1);                                                                 // get pointers to objects which position (Game.Obj.pos) is inside 'obox'   , process only objects with 'obj_type' OBJ_TYPE (-1=process all types), this function does not clear 'objects' container at start which means that objects are added to the container
   WorldManager& objGet   (MemPtr objects, C Ball    &ball   , Int obj_type=-1) {objects.clear(); return objGetAdd(objects, ball   , obj_type);} // get pointers to objects which position (Game.Obj.pos) is inside 'ball'   , process only objects with 'obj_type' OBJ_TYPE (-1=process all types)
   WorldManager& objGet   (MemPtr objects, C Capsule &capsule, Int obj_type=-1) {objects.clear(); return objGetAdd(objects, capsule, obj_type);} // get pointers to objects which position (Game.Obj.pos) is inside 'capsule', process only objects with 'obj_type' OBJ_TYPE (-1=process all types)
   WorldManager& objGet   (MemPtr objects, C Box     &box    , Int obj_type=-1) {objects.clear(); return objGetAdd(objects, box    , obj_type);} // get pointers to objects which position (Game.Obj.pos) is inside 'box'    , process only objects with 'obj_type' OBJ_TYPE (-1=process all types)
   WorldManager& objGet   (MemPtr objects, C OBox    &obox   , Int obj_type=-1) {objects.clear(); return objGetAdd(objects, obox   , obj_type);} // get pointers to objects which position (Game.Obj.pos) is inside 'obox'   , process only objects with 'obj_type' OBJ_TYPE (-1=process all types)

   Obj* findObjById(C UID &obj_id, Int obj_type=-1); // find world object by its Unique ID (this is the ID of the world object itself, and not its base object or class), 'obj_type'=OBJ_TYPE of the object (or if you don't know it, then use -1), null on fail (if not found)

   // terrain
   WorldManager& terrainAddDecal  (C Color &color, C MaterialPtr &material, C Matrix &  decal_matrix, Flt time_to_fade_out=10); // add a Decal       to current World's terrain
   WorldManager& terrainAddOverlay(                C MaterialPtr &material, C Matrix &overlay_matrix, Flt time_to_fade_out=10); // add a MeshOverlay to current World's terrain

   // path
   AreaPath2D* path2DGet     (C VecI2 &xz ); // get pointer to Area paths at given Area coordinates, returns null when path's don't exist at specified coordinates
   Bool        path2DWalkable(C Vec   &pos); // check if path is walkable at specified world position
   void        path2DBuild   (            ); // call this once after making changes to AreaPath2D's to rebuild the path database

   // update
   Bool updated       (           ) {return _updated        ;} // if current world has been updated at least once since it was loaded, you can use this method to startup loading screen
   Flt  updateProgress(           ) {return _update_progress;} // get update progress (0..1), this can be called in a secondary thread to access the progress of updating the world using 'update' method
   void updateBreak   (           );                           // break updating, this can be called from a secondary thread to break any current world updating, for example if during loading a world the user requests quitting the game, you can break the loading and exit immediately
   void update        (C Vec2 &xz );                           // update, 'xz' =x and z coordinates of center of action (in meters), the parameter is used only for WORLD_STREAM mode (for other modes it is ignored)
   void update        (C Vec  &pos) {update(pos.xz());}        // update, 'pos'=                       center of action (in meters), the parameter is used only for WORLD_STREAM mode (for other modes it is ignored)
   // World update automatically loads all needed areas located nearby the center of action (and unloads those which are too far away).
   // Additionally it calls the following methods:
   //    D.grassUpdate()
   //    Physics.startSimulation().stopSimulation()
   //    Game.Obj.update() on all active game objects (which are located in AREA_ACTIVE areas)

   // draw
   void draw(); // call this inside Render function for every RENDER_MODE

  ~WorldManager();
   WorldManager();

private:
   struct ObjContainer
   {
      CPtr         type;
      ObjMap *map ;
   };

   UID        _id;
   Str        _name,
              _data_path;
   WORLD_MODE _mode;

   Bool _updated, _update_break;
   Byte _update_count;
   Flt  _update_progress;
   Int  _areas_to_load;

   Int                _rangei, _rangei2, _rangei2_inactive, _rangei2_cache;
   Flt                _range;
   Vec2               _xz;
   VecI2              _xzi;
   Memc _obj_container;
   Memc _obj_newly_added;
   RectI              _area_active_rect, _area_loaded_rect;
   Memc _area_active    , _area_draw, _area_draw_shadow, _area_draw_secondary,
                      _area_inactive  ,
                      _area_cache     ,
                      _area_background;
   Area::Data&      (*_area_data)(Area::Data* &data, Area &area);
   Grid         _grid;
   PathWorld          _path;
   WorldSettings      _settings;

   UInt     _path_iteration;
   PathFind _path_find;
  _Memc     _path_node, _path_neighbor;

   SyncLock  _lock;
   Thread    _thread;
   SyncEvent _thread_event;

   struct Decal2       : Decal       {Flt time;};   Memc _decals       ;
   struct MeshOverlay2 : MeshOverlay {Flt time;};   Memc _mesh_overlays;

   Flt _time_area_update_state,

       _time_area_update_state_now ,
       _time_area_update_state_back,
       _time_area_update_state_path,
       
       _time_area_update_state_unload_cache,
       _time_area_update_state_unload,
       _time_area_update_state_load,
       _time_area_update_state_load_data,
       _time_area_update_state_activate,
       _time_area_update_state_deactivate,

       _time_obj_update;

   T1(TYPE) static Area::Data& NewAreaData(Area::Data* &data, Area &area) {data=new TYPE(area); return *data;}
   T1(TYPE) WorldManager& _setAreaData() {ASSERT_BASE_EXTENDED(); _area_data=NewAreaData; return T;}
            WorldManager& _setObjType (ObjMap &obj_map, Int obj_type, CPtr c_type);
   T1(TYPE) friend struct EE::Reference;
   NO_COPY_CONSTRUCTOR(WorldManager);
}extern
   World; // Main World

 

 

 

 

 

 

 

 

 

 

 

 

 

 

| whaison | C++ | 06:31 | comments(0) | - | pookmark |
            
2018.03.23 Friday
Foo Engine HeaderFile .h
 
/******************************************************************************/
#pragma once // include the header only once
/******************************************************************************/
#define ENGINE_BUILD 52 // this is an integer value specifying the build iteration of Esenthel Engine, this gets incremented with each new release
/******************************************************************************

   Following defines are available, they are always set to 0 (disabled) or 1 (enabled)
      WINDOWS         - Windows                       platform
      WINDOWS_DESKTOP - Windows Desktop               platform
      WINDOWS_PHONE   - Windows Phone                 platform
      MAC             - Mac OS X                      platform
      IOS             - iOS                           platform
      LINUX           - Linux                         platform
      ANDROID         - Android                       platform
      WEB             - Web                           platform
      DESKTOP         - Windows Desktop, Mac, Linux   platform
      MOBILE          - Windows Phone  , iOS, Android platform
      APPLE           - Mac, iOS                      platform
      X64             - 64-bit                        platform
      DEBUG           - Debug mode

   Sample Usage:

      #if WINDOWS
         This line will compile only on Windows platform!
      #endif

/******************************************************************************/
// DETECT PLATFORM
/******************************************************************************/
// 32/64-bit
#if defined _WIN64 || defined __LP64__
   #define X64 1 // 64-bit
#else
   #define X64 0 // 32-bit
#endif

// ARM
#if (defined _M_ARM || defined __arm__) || (defined _M_ARM64 || defined __aarch64__)
   #define ARM 1
#else
   #define ARM 0
#endif

// Windows
#ifdef _WIN32
   #ifdef WINAPI_FAMILY
      #include 
      #define WINDOWS_OLD (WINAPI_FAMILY==WINAPI_FAMILY_DESKTOP_APP)
   #else
      #define WINDOWS_OLD 1
   #endif
   #define WINDOWS_NEW (!WINDOWS_OLD)
   #define PLATFORM(windows, unix) windows
#else
   #define WINDOWS_OLD 0
   #define WINDOWS_NEW 0
   #define PLATFORM(windows, unix) unix
#endif

// Apple - Mac or iOS
#ifdef __APPLE__
   #include 
   #if TARGET_OS_IPHONE // iOS
      #define MAC 0
      #define IOS 1
   #else // Mac
      #define MAC 1
      #define IOS 0
   #endif
   #if TARGET_IPHONE_SIMULATOR // iOS Simulator
      #define IOS_SIMULATOR 1
   #endif
#else
   #define MAC 0
   #define IOS 0
#endif

// Android
#ifdef ANDROID
   #undef  ANDROID
   #define ANDROID 1
#else
   #define ANDROID 0
#endif

// Linux
#if defined __linux__ && !ANDROID // Android also has '__linux__' defined
   #define LINUX 1
#else
   #define LINUX 0
#endif

// Web
#ifdef EMSCRIPTEN
   #define WEB 1
#else
   #define WEB 0
#endif

// Other
#define WINDOWS         (WINDOWS_OLD || WINDOWS_NEW)
#define WINDOWS_PHONE   (WINDOWS     &&  ARM       ) // can't use WINAPI_FAMILY_PHONE_APP because that's only for Win8
#define WINDOWS_DESKTOP (WINDOWS     && !ARM       )

#define APPLE (MAC || IOS)

#define DESKTOP (WINDOWS_DESKTOP || MAC || LINUX  )
#define MOBILE  (WINDOWS_PHONE   || IOS || ANDROID)

#if (WINDOWS+MAC+IOS+LINUX+ANDROID+WEB)!=1
   #error Unsupported platform detected
#endif
/******************************************************************************/
#include "_/headers.h"
#include "_/types.h"
/******************************************************************************/
namespace EE // Esenthel Engine namespace
{
   /******************************************************************************/
   #pragma pack(push, 4)
   #include "_/defines.h"
   #include "_/structs.h"
   /******************************************************************************/
   // MISC
   /******************************************************************************/
   #include "Misc/Character.h"
   #include "Memory/Mem Simple.h"
   #include "Misc/String8.h"
   #include "Misc/String.h"
   #include "Misc/String Functions.h"
   #include "Misc/Cpu.h"
   #include "Misc/Misc.h"
   #include "Memory/_Memc.h"
   #include "Memory/Mem Continuous.h"
   #include "Misc/UID.h"
   #include "Memory/Memory.h"
   #include "Memory/Cipher.h"
   #include "Memory/Hash.h"
   #include "Memory/Mem Temporary.h"
   #include "Memory/Fixed Array.h"
   #include "Memory/_Memb.h"
   #include "Memory/Mem Block.h"
   #include "Memory/_Memx.h"
   #include "Memory/Mem Extended.h"
   #include "Memory/_Meml.h"
   #include "Memory/Mem List.h"
   #include "Memory/Mem Pointer.h"
   #include "Misc/String Borrowed.h"
   #include "Memory/Node.h"
   #include "Misc/Date Time.h"
   #include "Memory/Index.h"
   //
   #include "Math/Vector.h"
   #include "Graphics/Color.h"
   #include "Misc/Timer.h"
   #include "Math/Matrix.h"
   #include "Math/Math.h"
   #include "Math/Orientation.h"
   #include "Math/Shapes/Rectangle.h"
   //
   #include "Misc/Sort.h"
   #include "Misc/Thread.h"
   #include "Misc/Reference.h"
   #include "Memory/_Memc Thread Safe.h"
   #include "Memory/Mem Continuous Thread Safe.h"
   #include "Memory/_Cache.h"
   #include "Memory/Cache.h"
   #include "Memory/_Map.h"
   #include "Memory/Map.h"
   #include "Misc/States.h"
   #include "File/File.h"
   #include "File/File Text.h"
   #include "File/IO.h"
   #include "File/Chunk.h"
   #include "Misc/Compress.h"
   #include "File/Pak.h"
   #include "Misc/Enum.h"
   #include "Misc/Param.h"
   #include "File/Xml.h"
   #include "Platforms/Android.h"
   #include "Misc/Callback.h"
   #include "Misc/DLL.h"
   /******************************************************************************/
   // MATH
   /******************************************************************************/
   #include "Math/Shapes/Plane.h"
   #include "Math/Shapes/Edge.h"
   #include "Math/Shapes/Triangle.h"
   #include "Math/Shapes/Quad.h"
   #include "Math/Shapes/Box.h"
   #include "Math/Shapes/Circle.h"
   #include "Math/Shapes/Ball.h"
   #include "Math/Shapes/Capsule.h"
   #include "Math/Shapes/Tube.h"
   #include "Math/Shapes/Cone.h"
   #include "Math/Shapes/Pyramid.h"
   #include "Math/Shapes/Torus.h"
   #include "Math/Shapes/Polygon.h"
   #include "Math/Shape.h"
   #include "Math/Number.h"
   #include "Math/Quaternion.h"
   #include "Math/Camera.h"
   #include "Math/Calculate.h"
   #include "Math/Random.h"
   #include "Math/Frustum.h"
   /******************************************************************************/
   // ANIMATION
   /******************************************************************************/
   #include "Animation/Skeleton.h"
   #include "Animation/Animation Keys.h"
   #include "Animation/Animation.h"
   #include "Animation/Motion.h"
   /******************************************************************************/
   // GRAPHICS
   /******************************************************************************/
   #include "Graphics/Display State.h"
   #include "Graphics/Image.h"
   #include "Graphics/Image Atlas.h"
   #include "Graphics/Image RT.h"
   #include "Gui/Font.h"
   #include "Gui/Text Style.h"
   #include "Graphics/Material.h"
   #include "Graphics/Display Draw.h"
   #include "Graphics/Renderer.h"
   #include "Graphics/Display.h"
   #include "Graphics/Light.h"
   #include "Graphics/Shader.h"
   #include "Graphics/Shader Main.h"
   #include "Graphics/Vertex Index Buffer Ex.h"
   #include "Graphics/Vertex Index Buffer.h"
   #include "Graphics/Sun.h"
   #include "Graphics/Fur.h"
   #include "Graphics/Effects 2D.h"
   #include "Graphics/Environment.h"
   /******************************************************************************/
   // SOUND
   /******************************************************************************/
   #include "Sound/Sound Extra.h"
   #include "Sound/Sound Stream.h"
   #include "Sound/Sound Buffer.h"
   #include "Sound/Sound.h"
   #include "Sound/Music.h"
   /******************************************************************************/
   // MESH
   /******************************************************************************/
   #include "Mesh/Mesh Csg.h"
   #include "Mesh/Mesh Render.h"
   #include "Mesh/Mesh Base.h"
   #include "Mesh/Mesh Part.h"
   #include "Mesh/Mesh Lod.h"
   #include "Mesh/Mesh Mesh.h"
   #include "Mesh/Mesh Group.h"
   #include "Mesh/Mesh Cuts.h"
   #include "Mesh/Mesh Import.h"
   #include "Mesh/Mesh Overlay.h"
   #include "Mesh/Material Palette.h"
   /******************************************************************************/
   // PHYSICS
   /******************************************************************************/
   #include "Physics/Phys Material.h"
   #include "Physics/Phys Body.h"
   #include "Physics/Joint.h"
   #include "Physics/Actor.h"
   #include "Physics/Vehicle.h"
   #include "Physics/Physics.h"
   #include "Physics/Aggregate.h"
   #include "Physics/Controller.h"
   #include "Physics/Ragdoll.h"
   #include "Physics/Grab.h"
   #include "Physics/Cloth.h"
   #include "Physics/Destruct Mesh.h"
   /******************************************************************************/
   //
   /******************************************************************************/
   #include "Misc/Application.h"
   #include "Misc/Windows.h"
   #include "Input/Input Buttons.h"
   #include "Input/Input.h"
   #include "Input/Keyboard.h"
   #include "Input/Mouse.h"
   #include "Input/Joypad.h"
   #include "Memory/_Grid.h"
   #include "Memory/Grid.h"
   #include "Misc/Pathfind 2D.h"
   #include "Misc/Pathfind.h"
   #include "Misc/Video.h"
   #include "Misc/Member.h"
   #include "Graphics/Water.h"
   #include "Graphics/Sky.h"
   #include "Graphics/Fog.h"
   #include "Graphics/Clouds.h"
   #include "Graphics/Particle.h"
   #include "Graphics/Effects 3D.h"
   #include "Misc/Object.h"
   #include "Mesh/Heightmap.h"
   #include "Mesh/Blocks.h"
   /******************************************************************************/
   // GUI
   /******************************************************************************/
   #include "Gui/Panel Image.h"
   #include "Gui/Panel.h"
   #include "Gui/Gui Skin.h"
   #include "Gui/Gui Object.h"
   #include "Gui/Gui Objects.h"
   #include "Gui/Gui.h"
   #include "Gui/Objects/Text.h"
   #include "Gui/Objects/Gui Image.h"
   #include "Gui/Objects/Button.h"
   #include "Gui/Objects/Tabs.h"
   #include "Gui/Objects/CheckBox.h"
   #include "Gui/Objects/Progress.h"
   #include "Gui/Objects/Slider.h"
   #include "Gui/Objects/SlideBar.h"
   #include "Gui/Objects/TextLine.h"
   #include "Gui/Objects/TextBox.h"
   #include "Gui/Objects/Region.h"
   #include "Gui/Objects/Viewport.h"
   #include "Gui/Objects/Gui Custom.h"
   #include "Gui/Objects/List.h"
   #include "Gui/Objects/Menu.h"
   #include "Gui/Objects/MenuBar.h"
   #include "Gui/Objects/ComboBox.h"
   #include "Gui/Objects/Window.h"
   #include "Gui/Objects/Window IO.h"
   #include "Gui/Objects/Desktop.h"
   #include "Gui/Objects/Property.h"
   #include "Gui/Objects/Color Picker.h"
   /******************************************************************************/
   // GAME
   /******************************************************************************/
   #include "Game/Obj.h"
   #include "Game/Objects/Static.h"
   #include "Game/Objects/Kinematic.h"
   #include "Game/Objects/Animatable.h"
   #include "Game/Objects/Destructible.h"
   #include "Game/Objects/Door.h"
   #include "Game/Objects/Item.h"
   #include "Game/Objects/Character.h"
   #include "Game/Objects/Obj Light Point.h"
   #include "Game/Objects/Obj Light Cone.h"
   #include "Game/Objects/Obj Particles.h"
   #include "Game/Objects/Obj Decal.h"
   #include "Game/Waypoint.h"
   #include "Game/Area.h"
   #include "Game/Mini Map.h"
   #include "Game/World.h"
   /******************************************************************************/
   // NET
   /******************************************************************************/
   #include "Net/Interpolator.h"
   #include "Net/Socket.h"
   #include "Net/Download.h"
   #include "Net/Patcher.h"
   #include "Net/Ftp.h"
   #include "Net/Connection.h"
   #include "Net/Net Object.h"
   #include "Net/Net World.h"
   #include "Net/Sql.h"
   #include "Net/Esenthel Store.h"
   #include "Net/Advertisement.h"
   #include "Net/Facebook.h"
   #include "Net/Store.h"
   #include "Net/Steam.h"
   #include "Net/Internet Cache.h"
   /******************************************************************************/
   // EDIT
   /******************************************************************************/
   #include "Edit/Save Changes.h"
   #include "Edit/Viewport4.h"
   #include "Edit/Version.h"
   #include "Edit/Undo.h"
   /******************************************************************************/
   // CODE
   /******************************************************************************/
   #include "Code/CE Shared.h"
   #include "Code/CE Symbol.h"
   #include "Code/CE Token.h"
   #include "Code/CE Macro.h"
   #include "Code/CE Parser.h"
   #include "Code/CE Code Col Line.h"
   #include "Code/CE Source.h"
   #include "Code/CE Environment.h"
   #include "Code/CE Expression.h"
   #include "Code/CE Compiler.h"
   #include "Code/CE Item.h"
   #include "Code/CE Find.h"
   #include "Code/CE.h"
   /******************************************************************************/
   #include "Edit/Editor Interface.h"
   #include "Graphics/Renderer Instancing.h"
   #include "Input/Touch.h"
   #include "_/inline.h"
   /******************************************************************************/
   #pragma pack(pop)
   /******************************************************************************/
} // namespace
/******************************************************************************/
using namespace EE;
/******************************************************************************/
// DECLARATIONS FOR USER PROVIDED MAIN FUNCTIONS
/******************************************************************************/
Bool Preload(); // this method is called only on Web platform, it is called before InitPre, it will be called continuously as long as you're returning 'true' inside it. You should use this method to optionally download necessary files, like "Engine.pak". Once you've finished downloading files, return 'false' so that the application can continue, and proceed to 'InitPre'. After that, 'Preload' will never be called again.
void InitPre(); // init before engine, in this function you can modify things like: applications settings (App), Display options (D), Renderer options (Renderer), camera parameters (Cam), file path settings (DataPath), loading data paks (Paks.add), etc. In this stage the engine is not yet fully initialized, so creating GPU (Images, Meshes, ..) and Sound data will fail, this data should be processed later, for example in Init().
Bool Init   (); // init after  engine
void Shut   (); // shut at exit
Bool Update (); // update
void Draw   (); // draw
/******************************************************************************/

| whaison | C++ | 06:13 | comments(0) | - | pookmark |
            
2018.03.20 Tuesday
ShaderToyToy3
v v https://www.shadertoy.com/view/MsfGRr
No WebGL available :(
0.00 00.0 fps
0 views, Tags:
Created by in

Comments (0)
Sign in to post a comment.

Shader Inputs
uniform vec3      iResolution;           // viewport resolution (in pixels)
uniform float iTime; // shader playback time (in seconds)
uniform float iTimeDelta; // render time (in seconds)
uniform int iFrame; // shader playback frame
uniform float iChannelTime[4]; // channel playback time (in seconds)
uniform vec3 iChannelResolution[4]; // channel resolution (in pixels)
uniform vec4 iMouse; // mouse pixel coords. xy: current (if MLB down), zw: click
uniform samplerXX iChannel0..3; // input channel. XX = 2D/Cube
uniform vec4 iDate; // (year, month, day, time in seconds)
uniform float iSampleRate; // sound sample rate (i.e., 44100)

Filter
Wrap
iChannel0

Filter
Wrap
iChannel1

Filter
Wrap
iChannel2

Filter
Wrap
iChannel3
Select input for iChannel
No Input
by shadertoy
Keyboard
by shadertoy

256 x 3
1 ch, int8
Webcam
by shadertoy

1280 x 720
4 ch, int8, sRGB
Microphone
by shadertoy

512 x 2
1 ch, int8
Soundcloud
by shadertoy

512 x 2
1 ch, int8
Pick Soundcloud track:

Buffer A
by shadertoy

Viewport Resolution
4 ch, Float32, linear
Buffer B
by shadertoy

Viewport Resolution
4 ch, Float32, linear
Buffer C
by shadertoy

Viewport Resolution
4 ch, Float32, linear
Buffer D
by shadertoy

Viewport Resolution
4 ch, Float32, linear

by



by



by



by



by



by



by



by



by





by



by



by



by



by



by



by



by



by





by


| whaison | ShaderDebugger | 13:37 | comments(0) | - | pookmark |
            
2018.03.20 Tuesday
ShadertoyCom_view_MsfGRr




AutoDeskAuto3DCADRenderingImage Licence.vid
キャプション






>https://www.shadertoy.com/view/MsfGRr

 

 

 

 

 

v v https://www.shadertoy.com/view/MsfGRr

No WebGL available :(
0.00 00.0 fps
0 views, Tags:
Created by in
 
Comments (0)
Sign in to post a comment.
 
Shader Inputs
uniform vec3      iResolution;           // viewport resolution (in pixels)
uniform float     iTime;                 // shader playback time (in seconds)
uniform float     iTimeDelta;            // render time (in seconds)
uniform int       iFrame;                // shader playback frame
uniform float     iChannelTime[4];       // channel playback time (in seconds)
uniform vec3      iChannelResolution[4]; // channel resolution (in pixels)
uniform vec4      iMouse;                // mouse pixel coords. xy: current (if MLB down), zw: click
uniform samplerXX iChannel0..3;          // input channel. XX = 2D/Cube
uniform vec4      iDate;                 // (year, month, day, time in seconds)
uniform float     iSampleRate;           // sound sample rate (i.e., 44100)

Filter
Wrap
iChannel0

Filter
Wrap
iChannel1

Filter
Wrap
iChannel2

Filter
Wrap
iChannel3
Select input for iChannel
No Input
by shadertoy
Keyboard
by shadertoy

256 x 3
1 ch, int8
Webcam
by shadertoy

1280 x 720
4 ch, int8, sRGB
Microphone
by shadertoy

512 x 2
1 ch, int8
Soundcloud
by shadertoy

512 x 2
1 ch, int8
Pick Soundcloud track:

Buffer A
by shadertoy

Viewport Resolution
4 ch, Float32, linear
Buffer B
by shadertoy

Viewport Resolution
4 ch, Float32, linear
Buffer C
by shadertoy

Viewport Resolution
4 ch, Float32, linear
Buffer D
by shadertoy

Viewport Resolution
4 ch, Float32, linear

by

 

by

 

by

 

by

 

by

 

by

 

by

 

by

 

by

 
 

by

 

by

 

by

 

by

 

by

 

by

 

by

 

by

 

by

 
 

by

 

by

 

by

 

by

 

by

 

by

 

by

 

by

 

by

 
 

by

 

by

&
| whaison | ShaderDebugger | 13:35 | comments(0) | - | pookmark |
            
2018.03.20 Tuesday
chinchiquderolean@outlook.jp

chinchiquderolean@outlook.jp

 

 

 

 

 

 

 

chinchiquderolean@outlook.jp

chinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jpchinchiquderolean@outlook.jp

| whaison | chinchiquderolean@outlook.jp | 13:00 | comments(0) | - | pookmark |
            
2018.03.19 Monday
おなかがすいたら、ごはんを食べる。。

 

ごはんを食べるには > お金がいる > お金は このwhaison.jugem.jpを見れば稼げる

 

ネットがみれる必要がある。 > ネットカフェに入る > 1時間で ソースコードと Microsoft  VisualStudiioライセンスを取得 dll か mll をコンパイルできる ように VisualStudia の コンパイル用 DLLとEXEをSSD とかFFDに全部コピー

 

あなたはそれを、ノートPCでずっと読み続けて、

 

 

| whaison | - | 19:17 | comments(0) | - | pookmark |
            
2017.04.12 Wednesday
Shader Debugger [ Unity ] と[ Visual Studio ] で [ DirectX 11 ] [Microsoft HLSL Shader Debugger ] [シェーダーのデバッガー] を使ってみる。00200

 

 

 

[ Unity ] と[  Visual Studio ] で

[ DirectX 11 ] [Microsoft HLSL Shader Debugger ]

[シェーダーのデバッガー] を使ってみる。

 

Shader の世界ではRGB が111のとき XYZ が  111 として デバッグするのがふつうのようですが。。

 

 

実はデバッガは存在しています。

 

https://docs.unity3d.com/550/Documentation/Manual/SL-DebuggingD3D11ShadersWithVS.html

Debugging DirectX 11 shaders with Visual Studio

の日本語翻訳 です。日本語版も ありますが あえて 信じません。

 

 

またMicrosoftのHLSL Shader Debugger  「シェーダーのデバッガー」ページも参考にします

https://msdn.microsoft.com/library/hh873197.aspx

のページも参考にしています。

 

Unity と Visual Studio で DirectX 11 シェーダーのデバッガー を使ってみる。

Microsoft が

Visual Studio 2012 に導入している

 

Graphics Debugger グラフィックスデバッガは、

Unity エディター

Windows スタンドアロン

Windows Store Apps

のような

プラットフォームからの

フレーム(フレームバッファのことかな?)

キャプチャするために

使用できます。

 

最近、グラフィックスデバッガにいくつかの修正が行われたので、

Visual Studio 2013 を使用することをお勧めします。

 

 

注意:

Unity エディターは、内部にデフォルトで複数の子ウィンドウが含まれています。

 

 

これは、グラフィックスデバッガが誤ったウィンドウのフレームをキャプチャすることがあるためです。

正しいウィンドウをキャプチャすることを確実にするために、‘Maximize on Play’ タブをチェックして、キャプチャする前に Play ボタンをクリックしましょう。ですが、これでも正しいウィンドウがキャプチャされるという保証はありません。これがフレームのキャプチャで Unity エディターの使用を推奨していない理由です。

注意: Unity が DirectX 11 で実行されている場合、フレームは、キャプチャのみすることができます。Player Settings (PC、Mac、LinuxStandalone) -> Other Settings から DirectX 11 を選択することができます。

Unity エディターや Windows スタンドアロンからフレームをキャプチャするステップ。

  • Visual Studio 2013 を起動します。
  • File -> New-> Project -> Visual C++- >Empty Project を選択します。
  • Project -> Properties -> Configuration Properties -> Debugging を選択します。
  • Command フィールドには、Unity Editor や Windows スタンドアロンの PATH を設定し、$(TargetPath) には、C:¥MyApp¥MyApp.exe のように置き換えます。
  • (オプション) Command Arguments の1つ「 -force-d3d11 」は、Windows スタンドアロンまたは Unity エディター で DirectX 11 の実行を強制します。
  •   グラフィックスデバッガを実行する準備が整いました。
  • Debug -> Graphics -> Start Diagnostics を選択します。
  • すべてが正しく設定されている場合、
  • アプリケーションの左上隅に
  • “Use ‘Print Screen’ key to capture a frame”
  • (フレームをキャプチャするために’Print Screen’キーを使用します)
  • のメッセージが表示されます。以下のスクリーンショットを参照してください。

DirectX 11のシェーダーをデバッグするステップ。

  • シェーダーをデバッグするには、デバッグシンボル付きでコンパイルする必要があり、
  • これを行うには、
  • #pragma enable_d3d11_debug_symbols を挿入します。
  • 基本的な例を作成してみましょう。
  • 新規の Unity プロジェクトを作成します。
  • アセットウィンドウに新しいシェーダーを作成します。
  • #pragma enable_d3d11_debug_symbols を挿入します。
  • 新しいマテリアルを作成し、カスタムシェーダーを選択します。
  • いくつかのオブジェクトにマテリアルを割り当てます。例えば、cube 。
  • Windows スタンドアロンアプリケーションをビルドします。
  • 上記の手順でフレームをキャプチャします。

シェーダーは次のようになります。

■■■■  −−−−−−−−−−−−−−−−−−−−−−−−−−−−PNG START■■■■  −

 

 

 

■■■■  −−−−−−−−−−−−−−−−−−−−−−−−−−−−PNG END■■■■  −

 

■■■HTML COLOR TEXT START------------------//////////////------/////////////////START■■■

 

BLUE = HLSLとcg.include で定義済みの関数など 固定のもの

RED = 赤引数とその引数から作られた重要な変数オブジェクト。

BRONZE ="String"

PURPLE = " cg.inc か シェーダ内 で定義された プロパティ "

PINK = 定義された struct 構造体

YELLOW =  プログラマブルシェーダでかきますよ宣言 CGPROGRAM ENDCG

--------------------------------- S H A D E R - C O D E _ E x a m p l e   ----------- S T A R T ////--////---////-


Shader "Custom/NewShader" {
Properties {
_MainTex ("Base (RGB)", 2D) = "white" {}
}
SubShader {
Tags { "RenderType"="Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf Lambert
#pragma enable_d3d11_debug_symbols
sampler2D _MainTex;
 struct Input {
float2 uv_MainTex;
};
void surf (Input IN, inout SurfaceOutput o) {
half4 c = tex2D (_MainTex, IN.uv_MainTex);
o.Albedo = c.rgb;
o.Alpha = c.a;
}
ENDCG
} 
FallBack "Diffuse"
}

--------------------------------- S H A D E R - C O D E _ E x a m p l e   ----------- E N D ////--////---////-

 

■■■HTML COLOR TEXT START------------------//////////////---------////////////////END■■■

 

すべてが正しく行われていれば、次のキャプチャされたフレームが表示され、

右クリックして Pixel History を選択し、

割り当てられたカスタムシェーダーを持つオブジェクトのピクセルを選択します。

Captured frame

Vertex Shader の次の play ボタン(上のスクリーンショットで赤丸部分)をクリックすると、

vertex シェーダーをデバッグすることができるはずです。

デバッグ中の vertex shader

Windows Store Apps

Windows Store Apps のために、ダミーの Visual Studio プロジェクトを作成する必要はなく

Unity がすでにプロジェクトを作成していますので、少しは簡単です。

フレームのキャプチャシェーダーをデバッグするための手順は

Unity Editor Windows スタンドアロンと同じようなものです。

その他のシェーダーテクニック

Unity エディターでは、RenderDoc を使用してシェーダーをデバッグすることもできます。

エディター内部からシーンをキャプチャして、スタンドアロンツールでデバッグを行います。

テクスチャ配列
シェーダーに固定関数 TexGen を実装する
| whaison | ShaderDebugger | 11:49 | comments(0) | - | pookmark |
            
2017.03.26 Sunday
https://blog.codecamp.jp/linux-install から必要なUSBの部分だけ抜粋 メモ 途中

 

 

https://blog.codecamp.jp/linux-install から必要なUSBの部分だけ抜粋

 

    OS X El CapitanとUbuntu 16.04 LTSのデュアルブート環境を構築する  http://ottan.xyz/el-capitan-ubuntu-dual-boot-4020/

 

 

注意点としては、Ubuntuのデフォルトのインストール状態ではWi-Fi接続を行うことができません。私が使用しているMacに搭載されているインターフェイスの情報は、上図の通りです。同一の「Broadcom BCM43xx」であれば、後述の手順でWi-Fiに接続できるようになります。

カードの種類: AirMac Extreme  (0x14E4, 0x134)

  ファームウェアのバージョン: Broadcom BCM43xx 1.0 (7.21.171.10.1a16)

 

 

注意点としては、Ubuntuのデフォルトのインストール状態ではWi-Fi接続を行うことができません。私が使用しているMacに搭載されているインターフェイスの情報は、上図の通りです。同一の「Broadcom BCM43xx」であれば、後述の手順でWi-Fiに接続できるようになります。

 

 

Ubuntu 16.04 LTSのISOファイルをダウンロードします。

iSO ready

http://releases.ubuntu.com/16.04/

http://releases.ubuntu.com/16.04/ubuntu-16.04.2-desktop-amd64.iso

 

/Applications/Utilities/Disk Utility.app

 

続いて、16GB以上のフラッシュメモリ(USBメモリ)を用意します。あらかじめ、ディスクユーティリティからフォーマットを行っておきます。フォーマットする際に、

「名前」は任意、

「フォーマット」は「MS-DOS(FAT)」、

「方式」は「GUIDパーティションマップ」

を選択します。

 

続いて、USBメモリを接続したまま、ターミナルを開きます。ターミナルは、「アプリケーション」→「ユーティリティ」フォルダの中にあります。ターミナルを開いたら、以下のコマンドを実行します。

$ diskutil list

T512G1GUIDnoMBP:~ t512g1guid$ diskutil list

/dev/disk0 (internal, physical):

   #:                       TYPE NAME                    SIZE       IDENTIFIER

   0:      GUID_partition_scheme                        *1.0 TB     disk0

   1:                        EFI EFI                     209.7 MB   disk0s1

   2:                  Apple_HFS Macintosh HD            499.0 GB   disk0s2

   3:                 Apple_Boot Recovery HD             650.0 MB   disk0s3

   4:       Microsoft Basic Data BOOTCAMP                500.7 GB   disk0s4

 

/dev/disk1 (external, physical):

   #:                       TYPE NAME                    SIZE       IDENTIFIER

   0:                            ENTERTAIN 2016         *5.9 GB     disk1

 

/dev/disk2 (external, physical):

   #:                       TYPE NAME                    SIZE       IDENTIFIER

   0:      GUID_partition_scheme                        *512.1 GB   disk2

   1:                        EFI EFI                     209.7 MB   disk2s1

   2:                  Apple_HFS T512G1GUID              255.5 GB   disk2s2

   3:                 Apple_Boot Recovery HD             650.0 MB   disk2s3

   4:                  Apple_HFS T512G2GUID              255.1 GB   disk2s4

   5:                 Apple_Boot Recovery HD             650.0 MB   disk2s5

 

/dev/disk3 (external, physical):

   #:                       TYPE NAME                    SIZE       IDENTIFIER

   0:      GUID_partition_scheme                        *512.1 GB   disk3

   1:                        EFI EFI                     209.7 MB   disk3s1

   2:                  Apple_HFS R512G4GUID              200.0 GB   disk3s2

   3:                  Apple_HFS R512G6GUID              55.7 GB    disk3s3

   4:                  Apple_HFS R512G3GUID              199.5 GB   disk3s4

   5:                 Apple_Boot Recovery HD             650.0 MB   disk3s5

   6:                  Apple_HFS R512G5GUID              55.6 GB    disk3s6

 

/dev/disk4 (external, physical):

   #:                       TYPE NAME                    SIZE       IDENTIFIER

   0:      GUID_partition_scheme                        *15.5 GB    disk4

   1:                        EFI EFI                     209.7 MB   disk4s1

   2:       Microsoft Basic Data UBUNTU010US             15.3 GB    disk4s2

 

T512G1GUIDnoMBP:~ t512g1guid$ 

T512G1GUIDnoMBP:~ t512g1guid$ 

T512G1GUIDnoMBP:~ t512g1guid$ 

USBメモリのディスクの番号を控えておきます。ここでは「disk4」が該当のUSBメモリです。

誤って他のディスクを消去することがないよう注意しましょう。

次に、

ターミナルから以下のコマンドを実行します。

disk4」は該当の番号に置き換えてください。

これで、アンマウントされます。

$ diskutil unmountDisk /dev/disk4

$ diskutil unmountDisk /dev/disk4

Unmount of all volumes on disk4 was successful

T512G1GUIDnoMBP:~ t512g1guid$ 

T512G1GUIDnoMBP:~ t512g1guid$ 

 

 

続いて、ダウンロードしたISOファイルの場所に移動します。例えば、「ダウンロード」フォルダに移動したい場合は、以下のコマンドを実行します。

 

 

以下のコマンドを実行します。

$ cd ~/Downloads

T512G1GUIDnoMBP:Downloads t512g1guid$ 

T512G1GUIDnoMBP:Downloads t512g1guid$ 

T512G1GUIDnoMBP:Downloads t512g1guid$ 

最後に、USBメモリにUbuntuのインストールディスクの書き込みを行います。

最後に、USBメモリにUbuntuのインストールディスクの書き込みを行います。

ターミナルから以下のコマンドを実行します。

「ubuntu-16.04-desktop-amd64.iso」は実際にダウンロードしたファイル名、「/dev/rdisk1」は事前に控えたディスクの番号に読み替えてください。「/dev/disk1」でも良いのですが、「/dev/rdisk1」とすると書き込みが速くなります。

$ sudo dd if=ubuntu-16.04.2-desktop-amd64.iso of=/dev/rdisk4 bs=1m

 

T512G1GUIDnoMBP:Downloads t512g1guid$ 

T512G1GUIDnoMBP:Downloads t512g1guid$ 

T512G1GUIDnoMBP:Downloads t512g1guid$ 

T512G1GUIDnoMBP:Downloads t512g1guid$ sudo dd if=ubuntu-16.04.2-desktop-amd64.iso of=/dev/rdisk4 bs=1m

Password:

--------------------------------5分ぐらいここで止まります。

1482+1 records in

1482+1 records out

1554186240 bytes transferred in 133.169906 secs (11670702 bytes/sec)

T512G1GUIDnoMBP:Downloads t512g1guid$ 

T512G1GUIDnoMBP:Downloads t512g1guid$ 

 

 

USBメモリへの書き込み完了後に上記のような警告ダイアログが出る可能性がありますが、とりあえず無視しておきます。

 

では、Ubuntuのパーティションの作成です。。。

ディスクユーティリティを開き、「Macintosh HD」が含まれるディスクを選択します。

選択した状態で「パーティション」をクリックします。

Ubuntuのパーティションを作成します。

「パーティション」は任意、

「フォーマット」は「MS-DOS(FAT)」、

「サイズ」は任意です。

50GBもあれば十分でしょう。

 

では、ブートローダーの準備をしましょう。。。

次に、以下のリンク

http://www.rodsbooks.com/refind/getting.html

から「rEFInd」をダウンロードします。

A binary zip file」を選択してダウンロードしてください。

ダウンロードしたら、任意のフォルダに解凍しておいてください。

 

ダウンロードしたら、「アプリケーション」→「ユーティリティ」フォルダにある「ターミナル」を起動します。

cdコマンドで、ダウンロードした「rEFInd」フォルダに移動したら、フォルダに含まれる「install.sh」を実行します。

 

 

T512G1GUIDnoMBP:refind-bin-0.10.5 t512g1guid$ ls

COPYING.txt banners mountesp

CREDITS.txt docs mvrefind

LICENSE.txt fonts refind

NEWS.txt keys refind-install

README.txt mkrlconf refind-mkdefault

T512G1GUIDnoMBP:refind-bin-0.10.5 t512g1guid$ 

 

refind-install.sh をダブルクリックして実行しました。

Last login: Sun Mar 26 03:36:47 on ttys001

/Users/t512g1guid/Downloads/refind-bin-0.10.5/refind-install ; exit;

T512G1GUIDnoMBP:~ t512g1guid$ /Users/t512g1guid/Downloads/refind-bin-0.10.5/refind-install ; exit;

Not running as root; attempting to elevate privileges via sudo....

Password:

ShimSource is none

Installing rEFInd on OS X....

Installing rEFInd to the partition mounted at /Volumes/ESP

 

**** ALERT: SIP ENABLED! ****

 

rEFInd cannot be installed because System Integrity Protection (SIP) seems

to be enabled! You must install rEFInd from your Recovery installation or

from another OS. To install from the Recovery system:

 

  1. Reboot

  2. Hold down Command+R as the chime sounds

  3. When the OS has booted, select Utilities->Terminal

  4. Change to this directory with the 'cd' command; it will probably be under

     /Volumes/T512G1GUID/Users/t512g1guid

  5. Re-run this script.

 

If you believe SIP is NOT enabled, you may attempt an installation anyhow,

but it may fail.

 

For more on this subject, see http://www.rodsbooks.com/refind/sip.html

 

Do you want to attempt installation (Y/N)? Y

Copied rEFInd binary files

 

Copying sample configuration file as refind.conf; edit this file to configure

rEFInd.

 

Could not set boot device property: 0xe00002bc

 

ALERT:

Installation has completed, but problems were detected. Review the output for

error messages and take corrective measures as necessary. You may need to

re-run this script or install manually before rEFInd will work.

 

Unmounting install dir

Volume EFI on disk0s1 unmounted

logout

Saving session...

...copying shared history...

...saving history...truncating history files...

...completed.

Deleting expired sessions...none found.

 

[プロセスが完了しました]

 

 

なお、ここでは

Downloads」フォルダに解凍してあるものとします。

 

Downloads」フォルダに解凍してあるものとします。

http://ottan.xyz/os-x-ubuntu-dual-boot-2-1236/

さて、El Capitanからは「SIP」と呼ばれる新たなセキュリティ機構が導入され、

デフォルトの状態では「rEFInd」をインストールすることができません。

そこで、Macをリカバリーモードで起動する必要があります。

 

Macを再起動し、+Rを押し続けてください。Macがリカバリーモードで起動します。リカバリーモードで起動したら、以下の手順で「rEFInd」をインストールします。

  1. メニューの「ユーティリティ」→「ターミナル」をクリックします
  2. ターミナルから、「rEFInd」を解凍しているフォルダに移動します。以下のコマンドを参照。「ottan」、「Downloads」、「refind-0.10.2」は適宜読み替えてください
  3. ./refind-installを実行。「Installation has completed successfully.」と表示されればインストールは完了です
  4. Macを通常モードで再起動します
# cd /Volumes/Macintosh¥ HD/Users/ottan/Downloads/refind-0.10.2

通常では、「rEFInd」のインストールが完了した時点で、作業は完了なのですが、どうもEl Capitanの環境ではこのままではうまく動作しないようです。Ubuntuのインストール完了後に、Macを(option)を押したまま再起動し、Ubuntuの起動ディスクが見えないようでしたら、以下の手順を試してみてください。

 

https://wavisaviwasavi.amebaownd.com/posts/208897

を参考に。。「

 

 

こちらを参考に、少々小細工します。ターミナルを開いて、以下のコマンドを実行します。

 

$ diskutil list
/dev/disk0 (internal, physical):
   #:                       TYPE NAME                    SIZE       IDENTIFIER
   0:      GUID_partition_scheme                        *251.0 GB   disk0
   1:                        EFI EFI                     209.7 MB   disk0s1
   2:                  Apple_HFS Macintosh HD            250.1 GB   disk0s2
   3:                 Apple_Boot Recovery HD             650.0 MB   disk0s3

「EFI」の「IDENTIFIER」を控えておいてください。次に、ターミナルから以下のコマンドを実行します。

$ mkdir /Volumes/efi
$ sudo mount -t msdos /dev/disk0s1 /Volumes/efi

「/dev/disk0s1」は事前に確認した「EFI」の「IDENTIFIER」です。適宜読み替えてください。次に、Finderを開き、/Volumes/efiに移動します。具体的には、Finderで、++Gで、移動する場所に上記を指定してください。

その後の作業については上記リンクに書いてある通りです。

 

 

 

http://ottan.xyz/el-capitan-ubuntu-dual-boot-4020/ 続き

| whaison | Operating System | 17:10 | comments(0) | - | pookmark |
            
2017.03.26 Sunday
NVIDIA GRID TM APPLICATION SIZING GUIDE  FOR: AUTODESK MAYA 2017 の日本語 翻 訳 用  HTML

 

https://knowledge.autodesk.com/ja/support/maya/troubleshooting/caas/sfdcarticles/sfdcarticles/JPN/System-requirements-for-Autodesk-Maya-2017.html

Maya の 動作環境 Oparation System にある NVIDIA GRID

オペレーティング システム
  • 10 Professional オペレーティング システムが Windows 7 (SP1)、Microsoft ® Windows ®
  • X 10.10.5 Apple ® Mac OS ®、10.11.x オペレーティング システム
  • Red Hat ® Enterprise Linux ® 6.5 WS オペレーティング システムと 7.2
  • CentOS 6.5 Linux オペレーティング システムと 7.2
  • グリッドと VMware の仮想化の NVIDIA ガイド

 

 

http://images.nvidia.com/content/grid/pdf/maya/NVIDIA-GRID%20Application-Guide-Autodesk-Maya.pdf

 

NVIDIA GRID

TM APPLICATION SIZING GUIDE FOR: AUTODESK MAYA 2017

 

 

NVIDIA GRID TM

APPLICATION SIZING GUIDE FOR: AUTODESK MAYA 2017

 

NVIDIA Performance Engineering

 

November 2016

 

-------------------------------------------------------------TABLE OF CONTENTS------------------------------------------------Start

 

Users per Server (UPS) ........................................................................ 3

Determining users per server ............................................................................... 4

Scalability Test Result Summary ........................................................................... 4

About the Application: Maya 2017 ......................................................................... 5

About NVIDIA GRID .......................................................................................... 6

Testing and methodology description ..................................................................... 7

Test Descriptions .......................................................................................... 8

Methodology Description ...................................................................................14

Appendix .........................................................................................20

-------------------------------------------------------------TABLE OF CONTENTS------------------------------------------------END

 

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 2

page2image4720

The purpose of this guide is to give a detailed analysis of how many users organizations can expect to get per servers based on performance testing with the Autodesk Maya applications. The NVIDIA Performance Lab worked in cooperation with the Autodesk Maya team to determine the maximum recommended number of users for the reference server configuration. Autodesk provided specific test scripts for the Maya 2017 software that are not generally available to end users, which the NVIDIA GRID performance team used to test specific combinations of virtual machines for performance and scale. These test scripts have been submitted to the SPEC review committee for inclusion in a Maya 2017 SPEC benchmark. Based on extensive testing, NVIDIA GRID provides the following performance and scalability recommendation.

!

NOTE: THESE NUMBERS ARE INTENDED TO BE USED A GENERAL GUIDANCE FOR A MAXIMUM NUMBER OF USERS PER HOST. CHANGES IN SERVER CONFIGURATION AND DIFFERENCES IN USAGE OF THE SOFTWARE WILL CAUSE PERFORMANCE TO VARY.

page3image13584

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 3

page3image14600

USERS PER SERVER (UPS)

DETERMINING USERS PER SERVER

Since Maya 2017 is used as both modeling and animation software, both user functions are important to consider when determining sizing of a virtual environment. Our testing reveals that these functions have differences between the amount of GPU used for each function that can be quite significant. Also, the tests have shown that the availability of vCPU resources (i.e. cores) is critical to performance for animation workloads.

These tests were written to replicate typical artist workflows which use effects and take advantage of the GPU.

The following tests were provided by Autodesk:

Table 1 Maya Test catagories

page4image7160

Test area

page4image8592

T est

Bifröst simulation

Bridge

page4image12800

Animation

page4image14024

Jungle

page4image15264

Modeling/T essellation

page4image16528

Character

page4image17776 page4image18528

XGen Hair

page4image19904 page4image20064

Tiger

For simplicity purposes, test will be often referenced by their shorter name, i.e. Character, Jungle, Bridge and Tiger, throughout this scalability report.

SCALABILITY TEST RESULT SUMMARY

The test results show that XGen modeling workloads, or any workload that requires OpenCL, the maximum possible number of users per server is four. Testing shows that with 4 concurrent M60-8Q profiles running simultaneously, all users see less than a 10% degradation in performance, well below discomfort level. We conclude that 4 concurrent users per server is the maximum. The Character modeling/tessellation test can support 16 VMs/Users per server, which is the maximum number of VM’s for the M60-2Q profile. Both the Tiger and Character workflow tests achieve the maximum number of VMs per GPU board, but the tests themselves are not GPU intensive. The frame buffer allocated to the VM was not entirely used by the application during test execution.

The Jungle animation and Bifröst simulation Bridge tests exceeded acceptable usability levels when reaching 10 VMs, and the Bridge test was found to perform better when more vCPU was added to the VM. Both tests put a larger demand on the CPU than GPU. In the case of the Bridge test, reconfiguring vCPU to 10 increased the performance

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 4

page4image32720

of the VM. However, as such, the host CPU would become too overallocated if the host had more than 10 VM’s running. On this class of server, the maximums VM’s which are concurrently executing for Bifröst simulation or the Character animation work modelled within the test reside between 6 and 8 users per server.

ABOUT THE APPLICATION: MAYA 2017

Maya provides a comprehensive suite of tools for your 3D content creation work ranging from modeling, animation, and dynamics through to painting and rendering to name but a few. With Maya, you can create and edit 3D models in a variety of modeling formats and animate your models using Maya’s suite of animation tools. Maya also provides a range of tools to allow you to render your animated 3D scenes to achieve photo realistic imagery and animated visual effects.

GPU Override is feature which is enabled by default in Maya 2017, this feature allows the GPU to perform operations which would otherwise be performed on the CPU. GPU Override requires Viewport 2.0 to be active, and the Evaluation Manager must be set to Serial or Parallel modes (Parallel is recommended and set by default). When the Maya preference “GPU Override” is enabled in Maya 2017, then standard deforming animation (i.e. Character animation) will offloaded to the GPU rather than CPU. If a user disables “GPU Override”, then these deforming animations would be processed on the CPU.

It is important to note, not all effects will be performed by the GPU even when GPU override is enabled. The following is a list of effects which make more use of the GPU:

  •   Scenes which use Viewport 2.0 effects such as lighting, shadows, SSAO, motion blur, depth peeling transparency.

  •   Playback and tumbling with very dense geometry.

  •   Generally, operations that use OpenCL (i.e. XGen).

  •   OpenSubdiv smoothing.

    The following is list of effect which are CPU limited and do not take advantage of the GPU:

  •   Playback or tumbling in scenes with very large numbers of objects.

  •   Rigging in general (i.e. editing Character rigs).

  •   Modeling on dense meshes.

  •   Particlesimulationandcaching.

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 5

page5image20216

ABOUT NVIDIA GRID

NVIDIA redefined visual computing by giving designers, engineers, scientists, and graphics artists the power to take on the biggest visualization challenges with immersive, interactive, photorealistic environments. NVIDIA Tesla GPU Accelerators bring this same power to the virtual desktop. Leveraging NVIDIA TeslaTM GPUs, NVIDIA GRIDTM delivers virtual workstations from the data center or cloud. Architects, engineers, and designers are now liberated from their desk and can access their applications and data anywhere. The NVIDIA Tesla M60 GPU accelerator works with NVIDIA GRID software to provide the industry’s highest user performance for virtualized workstations, desktops, and applications. This solution allows enterprises to virtualize any application—including professional graphics applications—and deliver them out to any device, anywhere.

Table 2 Tesla M60 Features and Specs

Virtualization Use Case

page6image9728

Performance-Optimized Graphics Virtualization

GPU Product

NVIDIA Tesla M60 - designed for the datacenter

GPU Architecture

page6image15696

NVIDIA MaxwellTM

GPUs per Board

2

Max User per Board

32(16 per GPU)

page6image22480

NVIDIA CUDA Cores

4096 NVIDIA CUDA Cores (2048 per GPU)

page6image25432

GPU Memory

16 GB of GDDR5 Memory (8 per GPU)

H.264 1080p30 Streams

36

page6image31120

Max Power Consumption

page6image32608

300 W

Thermal Solution

Active/Passive

Form Factor

PCIe 3.0 Dual Slot

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 6

page6image41048

TESTING AND METHODOLOGY DESCRIPTION

This section describes the tests performed and the method of testing used to determine sizing and server loads.

Test Environment

The following table describes the server host:

Table 1 Reference host specifications

Reference Host

Model

Supermicro SYS-2028GR-TRT

CPU

Intel Xeon CPU e5-2698 v3 @2.30Ghz

Logical Processors

page7image13216

64

Memory

page7image15680

256 GB

Storage

page7image17864

26 TB

GPU’s

page7image20728

2X Tesla M60

page7image22376

Hypervisor

VMware ESXi, 6.0.0, 3380124

page7image24960

VDI Management Software

VMware Horizon 7.01

NVIDIA GRID Software

page7image28200

Virtual Workstation

NVIDIA GRID Software

page7image31144

369.17(host) 367.43(guest)

page7image32432

Server BIOS Settings

Turbo Boost Technology

page7image35968

Enabled

Power Settings

page7image39168

Maximum Performance

page7image40616

Hyperthreading

page7image43160

Enabled

The VM operating system was Windows 7 SP1 with VMware Tools was installed. All testing was run on a single, full HD (1920x1080) monitor.

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 7

page7image46840

Test Descriptions Modelling/Tessellation: Character

The following is a screenshot of the Character test during test execution:

page8image1992

Figure 1 Character test screen shot

Figure 2 Character test display settings

page8image3264

Display settings, such as number of vertices, edges, faces, tris and UV’s, determine the

page8image4392

complexity of the model. The following screenshot describes the display settings used

page8image5440

for the test:

page8image6128

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 8

page8image7408

Animation: Jungle

page9image936

The Jungle test provides basic animation information for a specific object in a scene.

page9image2064

Below are two screenshots taken during Jungle test execution:

page9image2992

Figure 3 Jungle test screenshot

page9image3768

Figure 4 Jungle test screenshot

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 9

page9image5392

Color shading is turned on and off during the tests. The following screenshot describes the complexity of the scene:

Figure 5 Jungle test display settings

Bifröst Simulation: Bridge

page10image2488

Autodesk describes Bifröst as a procedural framework that can create simulated liquid

and aerodynamic effects using a FLIP (fluid implicit particle) solver. You can generate

liquid from emitters and have it fall under gravity, as well as interact with colliders to

direct the flow and create splashes, and use fields to create jets and other effects.

page10image7496

Figure 6 Bridge test screenshot

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 10

page10image9120

The following screenshot describes the model:

Figure 7 Bridge test display settings

XGen Hair: Tiger

page11image1864

XGen is described by Autodesk as users can procedurally create and style hair, fur and feathers

for characters.

With XGen users can

create realistic, self-shadowing fur and short hair on multi-

surface NURBS, polygonal and subdivision surface models. The Tiger tests is the most GPU

intensive test and requires OpenCL. The following is a screenshot of the Tiger test during test

execution:

page11image8704

Figure 8 Tiger test screenshot

The following screenshot shows the heads up display settings of the scene:

Figure 9 Tiger test display settings

Importance of vCPU vs. vGPU

Configuring the virtualized environment is essential for providing a consistently performant user experience. Improper configuration can lead to errors within the

page11image12208

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 11

page11image13224

application, sluggish performance or worse yet, application crashes. Autodesk has provided some error detection within the application to assist users in understanding issues which that may use to address issues which can occur due to insufficient GPU resources.

For Maya to take advantage of the GPU and multi-threading, the test scripts automatically enabled Parallel Evaluation and GPU Override.

Figure 10 Maya test script parameters

The following is a screenshot of an error message which occurs if the application does not have the proper amount of graphics memory (frame buffer) available as a resource:

Figure 11 Error message due to low memory config

Additionally, certain workflows such as those captured in the XGen Hair (Tiger) test requires OpenCL. When virtualizing the GPU, and using the GRID M60 card, the only vGPU profile which enables OpenCL is the M60-8Q Profile. If the M60-8Q profile is not assigned for this workload, Maya will crash upon opening. The following application event 1000 error was captured in the Windows Event log.

page12image9480 page12image9648 page12image9816

Figure 12 Event 1000 Application Error

To avoid this application crash, users should consult the Maya output window which is displayed in front of the application. This output window will indicate this issues exist with graphic card drivers and/or Open CL requirements.

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 12

page12image13344

Other configuration items, such as vCPU, memory and network are equally essential to provide a great Maya user experience. These configuration items will be highlighted in the upcoming test approach sections.

Maya 3D Viewport Settings

Maya has several 3D viewport settings that the application can run. Each of these viewport settings may perform differently, therefore all tests ran using all 3 viewport settings. These settings were applied using environment variables and are as follows:

 DirectX 11  OpenGL
 CoreProfile

The default viewport setting is CoreProfile.

Test Metrics

VM Metrics

- Maya Application Logs o Total test runtime

- Windows Performance Counters o CPU

o Memory
o Disk
o Network
o NVIDIAGPU

The Windows NVIDIA GPU performance counters were added at NVIDIA GRID 367.17, 367.14 version release. These counters measured frame buffer (FB) used and GPU % Utilization within the VM.

Host Metrics

The following host metrics were captured and analyzed:

  • -  Esxtop (Utilization by Core)

  • -  NVIDIA-smi (GPU Usage) Test Limitations

    Automated scalability testing can be considered more aggressive by nature than a typical user workflow. In most cases, it is not typical that 10 users will be executing rendering requests simultaneously or even to the degree of which were replicated in multiple test iterations. As such, the test results from our automated scalability testing can be considered worst case scenario and in most cases, a host should be able to support more than the concluded amount of VMs. The degree to which higher

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 13

page13image16696

scalability would be achieved is dependent on the typical day to day activities of a user, such as the number of meetings and the length of lunch or breaks, multi-tasking, etc.

This type of peak performance testing leads to conservative estimates of scalability, by design. It is therefore likely that results in typical or even aggressively loaded datacenters will have higher scalability. These results indicate likely minimums for rarefied conditions, to serve as “safe” guidelines.

Methodology Description

The scalability testing was conducted in two phases.  Single benchmark phase

 Scalability phase
Single Benchmark Phase

In this phase, virtual machines were created with a standard configuration. The test suite of four tests were run on the individual VMs to determine the amount of critical resources each test workflow typically used.

To ensure that each workflow had adequate resources (vCPU, GPU and RAM) to perform the workflows optimally, the single benchmark VMs were intentionally overprovisioned with CPU and Memory; 16 vCPU, 16GB of RAM. Each benchmark test also used the M60-8Q vGPU profile which provided access to the entire GPU. The utilization rates of these resources as well as test run times were then analyzed to determine the optimal VM configuration for each workflow. In some test cases, tests were re-executed at scale after re-configuring VMs.

vGPU Calculation

The following table indicates the GPU memory (frame buffer) utilization rates of the M60-8Q profile. This value was calculated by examining how the 8GB frame buffer was being utilized within the VM during test execution. These values, assisted in identifying the appropriate vGPU profile needed to support each workflow as follows:

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 14

page14image15856

Table 2 Typical test resource utilization

page15image3304 page15image5440 page15image5760 page15image6080 page15image6400

Workflow

Test Name

% GPU Memory

GPU Memory

vGPU Profile

Comments

page15image10456 page15image10616 page15image10776 page15image10936 page15image11096 page15image11256 page15image11416 page15image11840 page15image12160 page15image12744 page15image12904 page15image13064 page15image13224

Bifröst Simulation

Bridge

11%

0.88 GB

M60-1Q

page15image16288 page15image16448 page15image16608 page15image16768 page15image16928 page15image17088 page15image17248 page15image17672 page15image17992 page15image18576 page15image18736 page15image18896 page15image19056

Modeling T exturing

Character

24%

1.92 GB

M60-2Q

page15image22160 page15image22320 page15image22480 page15image22640 page15image22800 page15image22960 page15image23120 page15image23544 page15image23864 page15image24448 page15image24608 page15image24768 page15image24928

XGen Hair

Tiger

34%

2.72 GB

M60-4Q M60-8Q

OpenCL requirement; M60- 8Q See below

page15image28624 page15image28944 page15image29104 page15image29264 page15image29424 page15image29584 page15image29744 page15image29904 page15image30328 page15image30648 page15image31232 page15image31392 page15image31552 page15image31712

Character Animation

Jungle

19%

1.52 GB

M60-2Q

page15image35840 page15image36904 page15image38072

 

page15image39000 page15image39160 page15image39320 page15image40392

Note: NVIDIA GRID with Tesla M60 supports both high-end graphics and CUDA/OpenCL accelerated computing

Since the XGen functionally within the Maya application requires OpenCL, the Tiger test required the M60-8Q profile. Currently OpenCL capabilities are only enabled using the M60-8Q profile.

vCPU Calculation

It is important to note that a VM with more vCPU does not necessarily out perform a VM with less vCPU when using multi-threaded applications. In most of the tests, the 8- vCPU configuration was adequate, however since Maya is multi-threaded, test runtimes for the Bridge and Character tests decreased when the vCPU was altered; the Character VM increased performance when the vCPU count was lowered to 4. Theory of operation for this phenomenon holds that the Maya application generates threads for every vCPU it finds. This can lead to thread contention, which decreases performance. The following tables describes the required vCPU for each test:

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 15

page15image51392

Table 3 vCPU configurations for testing

vCPU configuration becomes increasing important during the next phase of testing; scalability testing. Allocating too much vCPU to a VM can cause a performance overhead on the host. Allocating too little vCPU can cause sluggish performance no matter how much vGPU the VM has. Aggressive vCPU allocation management is warranted.

Single Benchmark Results

The following tables summarizes how the vCPU and vGPU were reconfigured after analyzing the single benchmarks to support each type of workflow:

Table 4 vGPU and vCPU configurations for each test

Workflow

Test Name

vCPU Reconfiguration

Bifröst Simulation

Bridge

10

Modeling/T essellation

Character

4

XGen Hair

Tiger

8

Character Animation

Jungle

8

page16image28960 page16image29384 page16image29704 page16image30768 page16image31088 page16image31408

Workflow

Test Name

vCPU

vGPU

page16image33720 page16image33880 page16image34040 page16image34464 page16image34624 page16image34784 page16image34944 page16image35424 page16image35584 page16image35744

Bifröst Simulation

Bridge*

10

M60-1Q

page16image38056 page16image38216 page16image38640 page16image38800 page16image38960 page16image39120 page16image39600 page16image39760 page16image39920

Modeling/T essellation

Character

4

M60-2Q

page16image42232 page16image42392 page16image42816 page16image42976 page16image43136 page16image43296 page16image43776 page16image43936 page16image44096

XGen Hair

Tiger

8

M60-8Q

page16image46248 page16image46408 page16image46568 page16image46992 page16image47152 page16image47312 page16image47472 page16image47952 page16image48112 page16image48272

Character Animation

Jungle

8

M60-2Q

page16image50744 page16image51064 page16image51488 page16image51808 page16image52128 page16image53296

 

page16image54224 page16image54384 page16image54544 page16image55616

Note: * Bifröst Simulation workflow within the Bridge test reported 11% decrease in test runtime when increasing vCPU from 8 to 10.

Scalability Testing Phase

The second phase of testing consisted of scalability test runs for each individual artist workflow. A series of scalability test runs were executed and were incremented; 4, 8, 10, 12, 16 VMs. Between each test run, results and metrics were analyzed to understand how the application was performing as well as how the shared host resources were being utilized. In some test cases, VMs were reconfigured to improve the VM test run time. All configuration used are highlighted in the forthcoming test results sections.

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 16

page16image64424

Over 500 tests were run during scalability tests. Test were initially executed using the optimal VM configuration determined in the single benchmark phase.

The vGPU profile assigned to each workflow dictates the amount of density which is achievable in regards to the scalability of concurrently running VMs on the host. For example, XGen Hair (Tiger) workflow, required the M60-8Q profile due to its OpenCL requirement, therefore the maximum number of VMs is 2 per board. Our test server has two NVIDIA Tesla M60 cards, each card has 2 GPU’s, totally 4 GPU’s. Therefore, the maximum amount of currently running VMs using the M60-8Q profile is 4. The following tables describes the maximum number of possible currently running VMs for each of the test workflows and their vGPU profile requirement:

Table 5 Maximum possible VMs for test

During scalability testing, three of the four workflows (Character, Jungle, Bridge) scaled up to 16 concurrent VMs and the test results were analyzed. The Tiger tests scaled up to 4 VMs.

Scalability Test Metrics

The Maya application logs were the first level of analysis. Total test runtimes were post- processed for additional calculations:

 Standard Deviation across all VMs
● This value can be used as indicator to instability. If a higher value is reported, test

run times are slower or faster from one VM to another.  Average runtime for each scalability test

● This value is the reported value for the entire scalability test run. For example, a 4VM scalability test, reports the average test runtime of all 4 VM test runtimes.

 Percentage change in test runtime was also calculated.

  • ●  This value was considered the final threshold value for determining the amount of VMs which the host could adequately support without severally degraded user experience.

  • ●  Test thresholds less than 30% were considered to deliver adequate user
    experience. This threshold value is slightly higher than a typical physical or single user threshold, taking in consideration of the aggressive nature of the stress test. This level therefore became the threshold for our testing.

Workflow

Test Name

vGPU

Max # of VMs

XGen Hair

page17image27000

Tiger

page17image28360
page17image28864 page17image29776

M60-8Q

page17image30968

4

Modeling/T essellation

Character

M60-2Q

16

Character Animation

Jungle

page17image38776

M60-2Q

16

Bifröst simulation

Bridge

page17image43552
page17image44368

M60-1Q

page17image45296

32

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 17

page17image48288

Once these outputted VM metrics were analyzed, the host metrics were analyzed to determine the test bottleneck to performance.

Scalability Test Results

The following tables describes the test results from our testing and the amount concurrent VMs adequately supported on the host:

Table 6 Concurrent users per host

T est Name

Test Area

# of VM’s

vCPU

vGPU

% Change Threshold

page18image14464 page18image14888

Tiger

page18image16592

XGen-Hair

page18image17936

4

page18image20016

8

page18image21376

M60-8Q

page18image23368 page18image23952

-7.87%

Cards at full capacity (32GB)

Character

Modeling/ T essellation

16

4

M60-2Q

-22.58%

page18image31712 page18image32136

Jungle

page18image33352

Character Animation

page18image34672

10

page18image36152

8

page18image37328

M60-2Q

page18image38808

-20.79%

page18image39992
page18image42448

Bridge

Bifröst Simulation

page18image44576 page18image44896

6

10

page18image48136 page18image48728

M60-1Q

-28.21%

page18image51216

!

NOTE: Overall, all the four artist workflows provided by Autodesk showed that the bottleneck on the host was CPU rather than GPU.

Although the Tiger and Character workflow tests could achieve the maximum number of VMs per GPU board, the tests themselves are not GPU intensive. Therefore, the frame buffer allocated to the VM was not entirely used by the application during test execution.

As in the Tiger and Character tests, the Jungle and Bridge tests also required more CPU than GPU. As such, the test threshold value was quickly surpassed when the amount of concurrent VMs increased to 10. The following table shows the increase in test runtime as the amount of concurrent VMs increased:

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 18

page18image64208

Table 7 Bridge test threshold results

As discovered in the single VM test, the Bridge test runtimes were most optional using 10vCPU. However, if the amount of concurrent VMs were increased to 32 to reach to GPU maximum capacity of the GRID M60-1Q profile, the host CPU would be over allocated (320 vCPU) since the host has 64 logical cores with hyper threading enabled. Powering on more VMs meant using more vCPU than the host had as a shared resource.

CONCLUSION

The test results show that XGen modeling workloads, or any workload that requires OpenCL, the maximum possible number of users per server is four. Testing shows that with 4 concurrent M60-8Q profiles running simultaneously, all users see less than a 10% degradation in performance, well below discomfort level. We conclude that 4 concurrent users per server is the maximum. The Character modeling test can support 16 VMs/Users per server, which is the maximum number of VM’s for the M60-2Q profile. Both the Tiger and Character workflow tests achieve the maximum number of VMs per GPU board, but the tests themselves are not GPU intensive. The frame buffer allocated to the VM was not entirely used by the application during test execution.

The Jungle and Bridge tests exceeded acceptable usability levels when reaching 10 VMs, and the Bridge test was found to perform better when more vCPU was added to the VM. Both tests put a larger demand on the CPU than GPU. In the case of the Bridge test, reconfiguring vCPU to 10 increased the performance of the VM. However, as such, the host CPU would become too overallocated if the host had more than 10 VM’s running. On this class of server, the maximums VM’s which are concurrently executing for Bifröst simulation or the Character animation work modelled within the test reside between 6 and 8 users per server.

Bridge Avg. Test Time- 1Q vGPU Profile - 10vCPU

% Change Threshold

1VM

6VM

8VM

1VM vs 6VMs

CoreProfile

02:35.4

03:36.4

page19image30272

04:12.3

page19image31600

-28.21%

OpenGL

02:35.2

03:36.5

04:09.2

-28.32%

DX11

02:35.6

page19image41792

03:36.6

page19image43376

04:09.2

-28.15%

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 19

page19image46928

ADDITIONAL TESTING: MAYA 2017 SPEC

Maya 2017 SPEC contains eight artist workflows. The 4 workflows referenced in this whitepaper are also included with SPEC. The following is a list of the tests included in SPEC:

  • -  Bifröst Bridge

  • -  Jungle Animation

  • -  Seven Space Animation

  • -  Space Crash

  • -  Seven Character Animation

  • -  XGen Hair Tiger

  • -  Character Model Texture

  • -  Toy store

    This SPEC test provides individual elapsed time test results for the different modes tested such as animation, Bifröst, smooth shade (SSAO, edges, texture, all lights), and wire. These elapsed times were compared to a physical NVIDIA workstation graphic card and the test results were within range. No crashes or errors were reported.

    The Tiger workflow was modified for SPEC; the same Tiger model is loaded but exercises the GPU more heavily by rotating the model on the screen. This SPEC Tiger workflow intends to model real Maya users who build models as they are animating on the screen and requires both powerful GPU and CPU. Since the Tiger XGen capabilities within Maya requires OpenCL, the SPEC benchmark was ran using the same GRID M60-8Q vGPU (8GB) profile as used in our original test.

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 20

page20image13736

APPENDIX

The following graphs illustrated GPU and CPU Utilization rates on the VM during a single benchmark test. This graph captures the entire SPEC benchmark (total of 8 tests).

page21image2032

Figure 13 GPU and CPU utilization rates

NVIDIA GRID Application Sizing Guide for Autodesk Maya 2017 www.nvidia.com/grid 21

page21image3736

page22image392

Notice

The information provided in this specification is believed to be accurate and reliable as of the date provided. However, NVIDIA Corporation (“NVIDIA”) does not give any representations or warranties, expressed or implied, as to the accuracy or completeness of such information. NVIDIA shall have no liability for the consequences or use of such information or for any infringement of patents or other rights of third parties that may result from its use. This publication supersedes and replaces all other specifications for the product that may have been previously supplied.

NVIDIA reserves the right to make corrections, modifications, enhancements, improvements, and other changes to this specification, at any time and/or to discontinue any product or service without notice. Customer should obtain the latest relevant specification before placing orders and should verify that such information is current and complete.

NVIDIA products are sold subject to the NVIDIA standard terms and conditions of sale supplied at the time of order acknowledgement, unless otherwise agreed in an individual sales agreement signed by authorized representatives of NVIDIA and customer. NVIDIA hereby expressly objects to applying any customer general terms and conditions with regard to the purchase of the NVIDIA product referenced in this specification.

NVIDIA products are not designed, authorized or warranted to be suitable for use in medical, military, aircraft, space or life support equipment, nor in applications where failure or malfunction of the NVIDIA product can reasonably be expected to result in personal injury, death or property or environmental damage. NVIDIA accepts no liability for inclusion and/or use of NVIDIA products in such equipment or applications and therefore such inclusion and/or use is at customer’s own risk.

NVIDIA makes no representation or warranty that products based on these specifications will be suitable for any specified use without further testing or modification. Testing of all parameters of each product is not necessarily performed by NVIDIA. It is customer’s sole responsibility to ensure the product is suitable and fit for the application planned by customer and to do the necessary testing for the application in order to avoid a default of the application or the product. Weaknesses in customer’s product designs may affect the quality and reliability of the NVIDIA product and may result in additional or different conditions and/or requirements beyond those contained in this specification. NVIDIA does not accept any liability related to any default, damage, costs or problem which may be based on or attributable to: (i) the use of the NVIDIA product in any manner that is contrary to this specification, or (ii) customer product designs.

No license, either expressed or implied, is granted under any NVIDIA patent right, copyright, or other NVIDIA intellectual property right under this specification. Information published by NVIDIA regarding third-party products or services does not constitute a license from NVIDIA to use such products or services or a warranty or endorsement thereof. Use of such information may require a license from a third party under the patents or other intellectual property rights of the third party, or a license from NVIDIA under the patents or other intellectual property rights of NVIDIA. Reproduction of information in this specification is permissible only if reproduction is approved by NVIDIA in writing, is reproduced without alteration, and is accompanied by all associated conditions, limitations, and notices.

ALL NVIDIA DESIGN SPECIFICATIONS, REFERENCE BOARDS, FILES, DRAWINGS, DIAGNOSTICS, LISTS, AND OTHER DOCUMENTS (TOGETHER AND SEPARATELY, “MATERIALS”) ARE BEING PROVIDED “AS IS.” NVIDIA MAKES NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE. Notwithstanding any damages that customer might incur for any reason whatsoever, NVIDIA’s aggregate and cumulative liability towards customer for the products described herein shall be limited in accordance with the NVIDIA terms and conditions of sale for the product.

HDMI

HDMI, the HDMI logo, and High-Definition Multimedia Interface are trademarks or registered trademarks of HDMI Licensing LLC.

OpenCL

OpenCL is a trademark of Apple Inc. used under license to the Khronos Group Inc.

Trademarks

NVIDIA and the NVIDIA logo are trademarks and/or registered trademarks of NVIDIA Corporation in the U.S. and other countries. Other company and product names may be trademarks of the respective companies with which they are associated.

Copyright

© 2016 NVIDIA Corporation. All rights reserved.

page22image36488

www.nvidia.com 

| whaison | Operating System | 15:55 | comments(0) | - | pookmark |
            
2017.03.20 Monday
https://en.wikipedia.org/wiki/Artificial_consciousness の 日本語訳 翻訳

人工意識

https://en.wikipedia.org/wiki/Artificial_consciousness の 日本語訳 翻訳

 

 

 

 

 

 

 

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Artificial consciousness 日本語訳 はじめ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

 

 

人工意識 ( Artificial consciousness  AC )

ウィキペディアから、無料の百科事典

他の用途については、人工意識(曖昧さ回避)を参照してください

機械意識MC)または合成意識Gamez 2008 ; Reggia 2013としても知られる人工意識[1]AC)は、人工知能および認知ロボットに関する分野です。人工意識の理論目的は、「合成されなければならないだろうが、設計された人工物に見られる意識」を定義することである(Aleksander 1995)。

神経科学は、ことを仮定する意識がの様々な部分の相互運用によって生成されたと呼ばれる、意識の神経相関その観点に課題があるものの、またはNCCを。ACの支持者は、構築することが可能であると考えているシステム(例えば、コンピュータのこのNCCの相互動作をエミュレートすることができるシステムを)。[2]

人工意識の概念もの哲学に熟考されている人工知能を通じて心、意識、そして精神状態についての質問[3]

 

内容

  [ 隠す ] 

 

哲学的な見解編集]

多くの仮定されたタイプの意識があるので、人工意識の潜在的な実装が多く存在する。哲学文献では、おそらく最も一般的な意識の分類法は「アクセス」と「驚異的な」変種である。アクセス意識は、これらの側面に関する経験驚異的な意識ではなく、一見逮捕することはできない経験のこれらの側面に関する「生の感触」の観点から、定性的に特徴付けされながら「それはどのようなものであるか」や、逮捕することができクオリア1997ブロック) 。

妥当性の議論編集]

タイプアイデンティティ理論家や他の懐疑主義者は、意識は必然的に身体的憲法に依存する性質を持っているので、意識は特定の物理的システムにおいてのみ実現できるという見解を保持している(Block 1978 ; Bickle 2003)。[4] [5]

ジョルジオButtazzoは、完全に自動化されたモードでの作業」、自律性をシミュレートするために私たちの現在の技術者の能力にもかかわらずと言う、彼ら[コンピュータ]が創造性、感情、または発揮することができない:「ユートピアまたは現実的な可能性は人工意識"彼の記事では自由意志をコンピュータ。洗濯機のように、コンポーネントによって操作されるスレーブです。 " [6]

因果的役割の観点から精神状態を定義する他の理論家(例えば、機能主義者)については、身体的憲法にかかわらず、因果的役割の同じパターンを具体化することができるシステムは、意識を含む同じ精神状態をインスタンス化する(Putnam 1967)。

計算基盤の議論編集]

ACの妥当性の最も明白な議論の1つは、David Chalmersによるものです。彼の記事Chalmers 2011で見つけた彼の提案は、おおよその種類の計算が意識的な心の所有に十分であるということです。アウトラインでは、彼はこうして彼の主張を守っている。コンピュータは計算を行う。計算は、他のシステムの抽象的因果関係を捕捉することができる。

Chalmersの提案の中で最も議論の余地がある部分は、精神的な特性が「組織的に不変」であるということです。精神的性質は、心理学的および現象論的の2種類である。信念や知覚のような心理的性質は、「その因果的役割によって特徴付けられる」ものである。彼はArmstrong 1968Lewis 1972の研究に、「同じ因果関係のトポロジーを持つイスラムが心理学的特性を共有する」と主張している。

現象学的性質は、それらの因果的役割の観点からは決定的ではない。現象学的性質は因果的役割による個体化に従うことを立証するために議論が必要である。Chalmersはこの目的のために彼のDancing Qualia議論を提供します。[7]

Chalmersは、同一の因果組織を持つエージェントが異なる経験を持つことができると仮定することから始まります。その後、彼は、因果関係を維持しながら、部品の交換(シリコンで置き換えられた神経部品、たとえば)によって、あるエージェントを他のエージェントに変更することを考えさせるようにと頼んでいます。Ex hypothesisでは、変容中のエージェントの経験は変化する(部品が交換された)が、因果トポロジーに変化はなく、したがってエージェントが経験の変化を「気付かせる」手段がない。

Chalmersがすべての精神的特性と外部接続が抽象的因果関係によって十分に捕捉されていると仮定して、問題を提起するAC物体の批評家。

倫理編集]

主な記事:人工知能機械倫理ロボット工学の倫理

特定の機械が意識していることが確かであれば、その権利は査定する必要がある倫理的な問題(例えば、法律上どのような権利があるか)であろう。例えば、建物または大型機械のツールまたは中央コンピュータとして所有および使用されている意識のあるコンピュータは、特定のあいまいさである。べき法律は、このような場合のために作られたことが、意識はまた、(例えば経験するマシンの能力の法的な定義を必要とする喜び痛みとして知られている、知覚力を)。人工意識は依然として理論上の主題であるため、そのような倫理は、しばしば小説の主題ではあるが(以下を参照)、議論も発展もされていない。

2003年のロープナー賞( Loebner Prize)競技規則のルールは、ロボットの権利の問題に明白に対処しました。

61.任意の年に、サリー大学またはケンブリッジセンターが入学した公的に入手可能なオープンソースのエントリーが銀メダルまたは金メダルを獲得した場合、メダルと現金賞は、そのエントリーの開発。そのような身体が特定できない場合、または2人以上の請求者の間に意見の不一致がある場合、メダルと現金賞は合衆国で合法的に所有することができるコンテスト開催地、現金授与式、金メダルなどの権利があります。[8]

研究と実装の提案編集]

意識の側面編集]

機械が人工的に意識されるためには、一般的に必要と思われる意識の様々な側面がある。意識が役割を果たしている様々な機能は、以下によって提案されたバーナードBaarsBaars 1988)など。Bernard Baarsによって提案された意識の機能は、定義と文脈設定、適応と学習、編集、フラッグとデバッグ、採用と制御、優先順位付けとアクセス制御、意思決定またはエグゼクティブ機能、類推機能、メタ認知と自己学習、監視機能、自動プログラミング機能、セルフメンテナンス機能を備えています。イゴール・アレクサンダーは、人工意識のための12の原則を提案した(Aleksander 1995)。これは次のようなものである:脳は状態機械であり、内側ニューロン区画化、意識学習と記憶、予測、自己意識、意味表現、学習発話、学習言語、意志、本能、感情の3つに分類される。ACの目的は、意識のこれらの側面および他の側面が、デジタルコンピュータなどの設計された人工物において合成され得るか否かを定義することである。このリストは網羅的なものではありません。カバーされていない他の多くがあります。

意識編集]

意識は、一側面を必要とすることができるが、の正確な定義には多くの問題がある意識がサルでのニューロスキャンの実験の結果は、状態または物体だけでなく、プロセスがニューロンを活性化することを示唆している。認識には、感覚や想像を通じて受け取った情報に基づいて各プロセスの代替モデルを作成してテストすること、予測を行うのにも役立ちます。このようなモデリングには多くの柔軟性が必要です。そのようなモデルを作成するには、物理​​世界のモデリング、自身の内部状態とプロセスのモデリング、および他の意識的エンティティのモデリングが含まれます。

認知には少なくとも3つのタイプがある:[9]意識があるかもしれないし、そうでないかもしれないエージェンシーの意識、目標意識、感覚運動意識。たとえば、代理店の意識では、昨日特定の行動を実行したことに気付いているかもしれませんが、今はそれを意識していません。目標の認識では、失われたオブジェクトを検索しなければならないことを意識しているかもしれませんが、今はそれを意識していません。感覚運動知覚では、あなたの手が物体に座っているが、今はそれを意識していないことに気づいているかもしれません。

認識の対象はしばしば意識しているので、意識と意識の区別はしばしばぼやけているか、同義語として使用されています。[10]

メモリ編集]

意識的な出来事は、学習、リハーサル、および検索において記憶システムと相互作用する[11] IDAモデル[12]は、知覚メモリの更新、中に意識の役割解明[13]過渡エピソード記憶、および手続き記憶を一過性のエピソード的および宣言的記憶はIDAに分布しているが、神経系においてもそうであるという証拠がある。[14] IDAでは、これらの2つのメモリは修正版の使用して計算実装されていKanerva疎分散メモリアーキテクチャを。[15]

学習編集]

学習はACのためにも必要であると考えられている。Bernard Baarsによって、意義深い経験が、新規で重要な出来事を表現し適応させる必要がある(Baars 1988)。アクセルCleeremansとルイス・ヒメネス、学習は「philogenetically [のセットとして定義されている原文のまま複雑な、予測不可能な環境での彼らの行動の上に柔軟な制御を得た薬剤を可能にするように批判的に主観的な経験に進化した感度に依存]高度な適応プロセス」 (Cleeremans 2001)。

予期編集]

予測可能な事象を予測する(または予測する)能力は、Igor AleksanderによってAC にとって重要と考えられる。[16] emergentist 複数のドラフト原理によって提案されたダニエル・デネット意識の説明、予測するのに有用である可能性があります。それは、現在の環境に合わせて、最も適切な「ドラフト」の評価と選択を含みます。予想には、自身の提案された行動の結果の予測と、他の主体による可能性のある行動の結果の予測が含まれる。

実世界の状態の関係は、生物が事象を予測することを可能にする意識的な生物の状態構造に反映される。[16]人工的に意識したマシンは、彼らが発生したときに、それらに対応することや、予想される事象を回避するためにpremptive行動を取る準備ができているために、イベントを正しく予測することができるはずです。ここでの意味は、現実世界と予測された世界の空間的、力学的、統計的、機能的、因果的なモデルを構築する柔軟でリアルタイムなコンポーネントが必要なことであり、現在では人工的意識を持っていることを実証することができます過去だけでなく将来も これを行うには、意識的なマシンは、チェスボードのような固定されたルールを持つ世界だけでなく、

主観的な経験編集]

主観的な経験やクオリアは、意識 難しい問題であると広く考えられている確かに、それは計算主義だけでなく、物理主義への挑戦を提起するために開催されています。他方では、これらの科学分野での研究を不可能にしてきた物理学における不確定性原理など、私たちが見ることができるものを制限する他の科学分野には問題がある

認知アーキテクチャの役割編集]

主な記事:認知アーキテクチャ

「認知的構造」という用語は、意識を含む人間の心の構造、またはその部分または機能に関する理論を指すことがある。別の文脈では、認知アーキテクチャはコンピュータ上で理論を実装する。その一例が、機械意識のための量子と生物に由来する認知アーキテクチャであるQuBICです。認知アーキテクチャの主な目標の1つは、包括的なコンピュータモデルにおける認知心理学のさまざまな結果を要約することです。しかし、結果は形式化された形式である必要があり、コンピュータプログラムの基礎となり得る。

シンボリックまたはハイブリッド提案編集]

フランクリンのインテリジェントディストリビューションエージェント編集]

スタン・フランクリン(1995年、2003年)を定義自律エージェントを有すると機能の意識をすることによって識別されるように、それは意識の機能のいくつかが可能であるときバーナードBaarsグローバルワークスペース理論(Baars  1988年1997年)。彼の脳の子供IDA(インテリジェントディストリビューションエージェント)は、GWTのソフトウェア実装であり、定義によって機能的に意識しています。IDAの任務は、米国海軍の船員のために、任務の終了後、各人の技能と嗜好を海軍のニーズに合わせて交渉することです。IDAはネイビーのデータベースと相互作用し、海軍の政策の大きなセットに従いながら、自然言語の電子メールの対話を介して船員と通信します。IDA計算モデルがでスタン・フランクリンの「配慮」ソフトウェア研究グループでは1996年から2001年の間に開発されたメンフィス大学Javaコードはおよそ4千万行で構成され、2001年のハイエンドワークステーションのリソースをほぼ完全に消費しています。これは、「特殊目的の、比較的独立した、ミニエージェントは通常、別のスレッドとして動作する小さなコードとして実装されている」というコードレットに大きく依存しています。IDAのトップダウンアーキテクチャでは、高レベルの認知機能が明示的にモデル化されている(詳細については、 Franklin 1995およびFranklin 2003を参照)。IDAは定義上機能的に意識されていますが、フランクリンは「多くの人間のような行動にもかかわらず、意識的な意識を彼自身の意識的なソフトウェアエージェントIDAには与えません。 IDAの内部と外部の行動を見ている間、私はそれをどうやって行うのですか?彼女の多くの人間のような行動にもかかわらず。これは、米国の海軍のいくつかのディテーターが、IDAの内外の行動を見ながら「はい、そうしている」と言って頭を何度も頷いているのを見ているのにもかかわらず、彼女の多くの人間のような行動にもかかわらず。これは、米国の海軍のいくつかのディテーターが、IDAの内外の行動を見ながら「はい、そうしている」と言って頭を何度も頷いているのを見ているのにもかかわらず、

ロン・サンの認知アーキテクチャCLARION 編集]

CLARIONは、意識と無意識の精神プロセスの区別を説明する2つのレベルの表現を提示します。

CLARIONは、さまざまな心理データの会計処理に成功しています。単純な反応スキルから複雑な認知スキルに至るまで、CLARIONを使用してよく知られている多くのスキル学習タスクがシミュレートされています。(SRT)タスク、人工文法学習(AGL)タスク、プロセス制御(PC)タスク、カテゴリ推論(CI)タスク、アルファベット演算(AA)タスク、およびハノイ塔(TOH)タスクが含まれます。タスク(Sun 2002)。その中でも、SRT、AGL、PCは典型的な暗黙の学習課題であり、心理学的実験の文脈で意識の概念を操作したので、意識の問題に非常に関連している。

Ben GoertzelさんのOpenCog 編集]

Ben Goertzelは、オープンソースのOpenCogプロジェクトを通じて、実装されたAGIを追求しています。現在のコードには、簡単な英語のコマンドを学習することができ、実世界のロボットとの統合が可能な仮想ペットが組み込まれています。香港ポリテクニック大学で実施されています。

つながり主義の提案編集]

ハイコネンの認知的アーキテクチャ編集]

Pentti Haikonen(2003)は、古典的なルールベースのコンピューティングは、ACを達成するには不十分だと考えている:「脳は確かにコンピュータではなく、思考はプログラミングされたコマンド列の実行ではありません。数字。Haikonenは、基礎的な計算ルールを特定して実装することによって意識を達成しようとするのではなく、認識内的イメージ内的スピーチ痛み喜びなどのプロセスを再現する特別な認知アーキテクチャ」を提案します感情これらの背後にある認知機能。このボトムアップ・アーキテクチャは、基本的なプロセッシング・ユニット、人工ニューロンアルゴリズムプログラムなしで、より高いレベルの機能を生み出すでしょう」ハイコーネンは、十分な複雑さを払って実装すると意識を高め、知覚プロセス、クロスモダリティ報告、再検査の可能性などを特徴とするスタイルと操作方法である」ハイコーネンはこのプロセスの意識の観点だけではなく、あるいはACが自発的に発生し、適切な神経に影響を受けた複雑さのアーキテクチャを持つ自律エージェントに出現するという見解である。これらは、Freeman(1999)Cotterill(2003)など多くの人が共有しています。Haikonen(2003)提案したアーキテクチャーの複雑さの低い実装では、ACを使用することはできないと言われていましたが、期待どおりの感情を示しました。ハイコネンの認知アーキテクチャの包括的な紹介については、Doan(2009)参照してください彼の哲学的見解の要約と共に、ハイコーネンの建築の更新された説明は、ハイコネン(2012年)に与えられています。Haikonen(2003)が提案したアーキテクチャーの複雑さの低い実装では、 ACを使用することはできないと言われていましたが、期待どおりの感情を示しました。ハイコネンの認知アーキテクチャの包括的な紹介については、Doan(2009)参照してください彼の哲学的見解の要約とともに、ハイコーネンの建築の更新された記述は、ハイコネン(2012年)に与えられています。Haikonen(2003)が提案したアーキテクチャーの複雑さの低い実装では、 ACを使用することはできないと言われていましたが、期待どおりの感情を示しました。ハイコネンの認知アーキテクチャの包括的な紹介については、Doan(2009)参照してください彼の哲学的見解の要約とともに、ハイコーネンの建築の更新された記述は、ハイコネン(2012年)に与えられています。

シャナハンの認知的アーキテクチャ編集]

Murray Shanahanは、グローバルな作業空間に関するBaarsのアイデアと内部シミュレーションのメカニズム(「想像力」)を組み合わせた認知的アーキテクチャを記述している(Shanahan 2006)。シャナハンの建築についての議論については、(Gamez 2008)and(Reggia 2013)および(Haikonen 2012)のChapter 20を参照してください

竹野の自己認識研究編集]

ロボットの自己認識は明治大学の竹野淳一[17]によって検討されている。竹野氏は、ミラー内の自己像と同一の像を持つ他のものを区別できるロボットを開発していると主張している[18] [19]。この主張は既にレビューされている(竹野、稲葉&鈴木2005)。竹野氏は、自己認識機能を持つMoNADと呼ばれる計算モジュールを最初に考案し、モジュールを階層的に接続することで感情、感情、理由の関係を定式化することで人工的意識システムを構築したと主張している(五十嵐、竹野2007)。武生はMoNADシステムを搭載したロボットを用いて鏡像認知実験を終了した。竹野氏は、「人間は自分の鏡像が自分自身の実際の部分よりも自分自身に近いと感じている」という自己身体理論を提案した。人工的意識を発達させるか人間の意識を明確にする上で最も重要な点は、自己認識の機能の発達であり、彼は彼の論文で物理的および数学的証拠を示していると主張する。[20]彼はまた、ロボットが感情を刺激したところ、メモリ内のエピソードを研究し、不快な感情(鳥越、竹野2009)の再発を防止するために、予測行動を取るために、この経験を使用することができることを実証しました。人工的意識を発達させるか人間の意識を明確にする上で最も重要な点は、自己認識の機能の発達であり、彼は彼の論文で物理的および数学的証拠を示していると主張する。[20]彼はまた、ロボットが感情を刺激したところ、メモリ内のエピソードを研究し、不快な感情(鳥越、竹野2009)の再発を防止するために、予測行動を取るために、この経験を使用することができることを実証しました。人工的意識を発達させるか人間の意識を明確にする上で最も重要な点は、自己認識の機能の発達であり、彼は彼の論文で物理的および数学的証拠を示していると主張する。[20]彼はまた、ロボットが感情を刺激したところ、メモリ内のエピソードを研究し、不快な感情(鳥越、竹野2009)の再発を防止するために、予測行動を取るために、この経験を使用することができることを実証しました。

アレクサンダーの不可能な心編集]

イゴールアレクサンダー、で神経システム工学の名誉教授インペリアルカレッジは、広く研究した人工ニューラルネットワーク彼の本の中および特許請求の範囲インポッシブルマインズ:私のニューロン、私の意識意識のマシンを作成するための原則はすでに存在していることを、それはに40年かかるだろうと言語を理解するためにそのような機械を訓練する[21]これが真実であるかどうかはまだ実証されておらず、脳が神経状態機械である「不可能な心」に述べられている基本原則は疑いの余地がない。[22]

Thaler's Creativity Machineパラダイム編集]

Stephen Thalerは1994年の特許で「意識と創造性の間の可能なつながり」を提案した。これは「自律的な有用情報のための装置」(DAGUI)、[23] [24] [25]、いわゆる「創造性機械」計算上の批評家はシナプスノイズの注入とニューラルネットへの分解を支配して、潜在的なアイデアや戦略と見なされる誤った記憶や混乱を誘発する。[26]彼は、この神経アーキテクチャと方法論を採用して、意識の主観的感覚を説明し、脳内の同様の騒音駆動神経アセンブリが全体的な皮質活動に対する疑わしい意義を発明すると主張する。[27] [28] [29] Thaler ' 機械理論の結果として得られた特許は、訓練されたニューラルネットを内部的に混乱させ、一連の神経活性化パターンを駆動して意識の流れを引き起こすような実験に触発されました。[28] [30] [31] [32] [33 ]

Michael Grazianoのアテンションスキーマ編集]

主な記事:Michael Graziano§意識の脳の基礎

2011年、Michael GrazianoとSabine Kastlerは、「人間の意識と社会神経科学との関係:意識の理論を注意スキーマとして提案する新しい仮説」という論文を発表した。[35] Grazianoは彼の本「意識と社会の脳」でこの理論の広範な議論を発表し続けた。[2]意識のこの注意スキーマ理論を、彼はそれを名前のように、脳は人の体の空間的な場所を追跡するだけでなく研究身体図式に類似注目スキーマを経由して様々な感覚入力、に注意を追跡することを提案しています。[2]これは、情報操作の特定のメカニズムを提案することによって人工的な意識に関係しており、私たちが意識して経験し記述したものを作り出し、それは現在の技術を使って機械で複製できるはずです。脳が人Xが物Yを知っていることが分かったとき、人Xが注意の強化をYに適用している状態をモデリングすることが効果的である。注意スキーマ理論では、同じプロセスを自分自身に適用することができる。脳は様々な感覚入力への注意を辿り、自分の意識は模範化されたモデルです。Grazianoはこのプロセスのために脳の特定の場所を提案し、そのような認識は脳内の専門家システムによって構築された計算された特徴であることを示唆している。人XがYに対して注意力強化を適用している状態をモデル化することは事実上有効である。注意スキーマ理論では、同じプロセスを自分自身に適用することができる。脳は様々な感覚入力への注意を辿り、自分の意識は模範化されたモデルです。Grazianoはこのプロセスのために脳の特定の場所を提案し、そのような認識は脳内の専門家システムによって構築された計算された特徴であることを示唆している。人XがYに注意力強化を適用している状態をモデル化することは事実上有効である。注意スキーマ理論では、同じプロセスを自分自身に適用することができる。脳は様々な感覚入力への注意を辿り、自分の意識は模範化されたモデルです。Grazianoはこのプロセスのために脳の特定の場所を提案し、そのような認識は脳内の専門家システムによって構築された計算された特徴であることを示唆している。

テスト編集]

試験機のための最もよく知られている方法で知能があるチューリングテストしかし、観察のみとして解釈される場合、この試験は観察の理論依存の科学原理の哲学に反するまた、人間の大人意識ではなく、人間の児童意識を模倣するアラン・チューリングの勧告は、真剣に取り組まなければならないことも示唆されている。[36]

ConsScaleなどの他のテストでは、生物システムに触発された機能の存在をテストしたり、人工システムの認知発達を測定したりします。

クオリア、または現象学的意識は、本質的に一人称現象です。様々なシステムが機能意識と相関する行動の様々な兆候を示しているかもしれないが、第三者の試験が一人称の現象学的特徴にアクセスできる考えられる方法はない。そのため、意識の経験的定義がないため、[37] ACにおける意識の存在のテストは不可能かもしれない。

2014年、Victor Argonovは、マシンが哲学的判断を生み出す能力に基づいて機械意識の非チューリングテストを提案しました。[38]彼は先天的(プリロード)これらの問題に関する哲学的知識のない哲学的議論の一方を有していない(そのようなクオリアや結合など)の意識のすべての問題の性質上判断を生成することができるならば決定論マシンは意識的と見なされなければならないと主張しています(そのようなモデルは、暗黙的または明示的に、これらの生き物の意識に関する知識を含んでいるかもしれない)。しかし、このテストは、意識の有無を検出するためにのみ使用できますが、意識の存在を否定することはできません。肯定的な結果は機械が意識していることを証明するが、否定的な結果は何も証明しない。例えば、

フィクション編集]

主な記事:シミュレートされた意識(サイエンスフィクション)

参照:フィクションの人工知能§センチメントAI

フィクションの作品から、人工的な意識を持つ人物(または少なくとも人が意識を持つことを暗示する人物):

  • AC -中2のAIをマージして作成したスプロール三部作によってウィリアム・ギブソン
  • エージェント -&nbs
| whaison | AI , Artificial intelligence 人工知能 , AC  Artificial consciousness 人工意識 | 19:25 | comments(0) | - | pookmark |