Blog for David Everhart at GarageGames.com

TorqueX 3D Hiding Meshes Part 2

David Everhart — 2008-09-03T03:23:08+00:00

Update on Hiding Meshes

I have finally completed my testing on my art asset creation. In my last blog, I had a barebones static mesh , that was able to hide and show meshes using my MeshManager class. I have since updated that class, and added some error handling, refactored some of the functions, replaced one of the loops with a find call, added xml definitions , and changed the return value to a MeshManagerResult object , which contains the status and any error messages. Here it is in its full glory:

using System;
using System.Collections.Generic;
using System.Text;
using GarageGames.Torque.Core;
using GarageGames.Torque.T3D;
namespace StarterGame3D
{
    /// <summary>
    /// This class manages meshes and their visibility. It uses static methods that can be called from anywhere. 
    /// </summary>
    public class MeshManager
    {
        /// <summary>
        /// This Method allows you to turn a meshs visibility on
        /// </summary>
        /// <param name="modelName">This is the name of the model in the TorqueObjectDatabase. </param>
        /// <param name="meshName">This is the name of the mesh in the model you want to show</param>
        public static MeshManagerResult ShowMesh(string modelName, string meshName)
        {
            return SetMeshVisibility(modelName,meshName, true);  
        }

        /// <summary>
        /// This Method allows you to turn a meshs visibility off
        /// </summary>
        /// <param name="modelName">This is the name of the model in the TorqueObjectDatabase. </param>
        /// <param name="meshName">This is the name of the mesh in the model you want to hide</param>
        public static MeshManagerResult HideMesh(string modelName, string meshName)
        {
            return SetMeshVisibility(modelName, meshName, false);
        }

        /// <summary>
        /// This Method allows you to turn off the visibility for all meshs in a model
        /// </summary>
        /// <param name="modelName">This is the name of the model in the TorqueObjectDatabase. </param>
        public static MeshManagerResult HideAllMeshes(string modelName)
        {
            return SetMeshVisibility(modelName, false);  
        }
        /// <summary>
        /// This Method allows you to turn on the visibility for all meshs in a model
        /// </summary>
        /// <param name="modelName">This is the name of the model in the TorqueObjectDatabase. </param>
        public static MeshManagerResult ShowAllMeshes(string modelName)
        {
            return SetMeshVisibility(modelName, true);  
        }

        /// <summary>
        /// This Method is the first overloaded method that allows you to turn
        /// off or on all the mesh's visibility in a model. 
        /// </summary>
        /// <param name="modelName">This is the name of the model in the TorqueObjectDatabase. </param>
        /// <param name="visible">This is a flag to indicate whether to turn all the model's meshes visibility on or off. true = turn on, false = turn off</param>
        private static MeshManagerResult SetMeshVisibility(string modelName, bool visible)
        {
            MeshManagerResult result = new MeshManagerResult();
            TorqueObject model = TorqueObjectDatabase.Instance.FindObject<TorqueObject>(modelName);
            if (model != null)
            {
                T3DTSRenderComponent componentRender = model.Components.FindComponent<T3DTSRenderComponent>();
                for (int meshIndex = 0; meshIndex < componentRender.Shape.Objects.Length; meshIndex++)
                {
                    if (visible)
                    {
                        componentRender.ShapeInstance.MeshObjects[meshIndex].Visibility = 1.0f;
                    }
                    else
                    {
                        componentRender.ShapeInstance.MeshObjects[meshIndex].Visibility = 0.0f;
                    }
                }
                result.Status = MeshManagerResult.StatusType.Success;
            }
            else
            {
                result.Status = MeshManagerResult.StatusType.Failed;
                result.ErrorMessage = "Could not find a model in TorqueObjectDatabase named " + modelName;
            }
            return result;
        }
        /// <summary>
        /// This Method is the second overloaded method that allows you to turn
        /// off or on all the mesh's visibility in a model. 
        /// </summary>
        /// <param name="modelName">This is the name of the model in the TorqueObjectDatabase. </param>
        /// <param name="meshName">This is the name of the mesh in the model</param>
        /// <param name="visible">This is a flag to indiciate whether to turn the mesh's visibility on or off. true = turn on, false = turn off</param>
        private static MeshManagerResult SetMeshVisibility(string modelName, string meshName, bool visible)
        {
            MeshManagerResult result = new MeshManagerResult();
            TorqueObject model = TorqueObjectDatabase.Instance.FindObject<TorqueObject>(modelName);
            if (model != null)
            {
                T3DTSRenderComponent componentRender = model.Components.FindComponent<T3DTSRenderComponent>();
                int meshIndex = componentRender.Shape.FindObject(meshName);
                if(meshIndex > -1)
                {
                    if (visible)
                    {
                        componentRender.ShapeInstance.MeshObjects[meshIndex].Visibility = 1.0f;
                    }
                    else
                    {
                        componentRender.ShapeInstance.MeshObjects[meshIndex].Visibility = 0.0f;
                    }
                    result.Status = MeshManagerResult.StatusType.Success;
                }
                else
                {
                    result.Status = MeshManagerResult.StatusType.Failed;
                    result.ErrorMessage = "Could not find a mesh in the shape named " + meshName;
                }
            }
            else
            {
                result.Status = MeshManagerResult.StatusType.Failed;
                result.ErrorMessage = "Could not find a model in TorqueObjectDatabase named " + modelName;
            }

            return result;

        }
        /// <summary>
        /// This method will get all meshes and the state of their visibility. It returns a List<string> 
        /// where each string is in the format of MeshName: [nameofmesh] ||Visibility: [visible or not]
        /// </summary>
        /// <param name="modelName">This is the name of the model in the TorqueObjectDatabase.</param>
        /// <param name="showHidden">Flag to indicate to show hidden or not</param>
        /// <param name="showVisible">Flag to indicate to show visible or not</param>
        /// <returns></returns>
         public static List<string> ListMeshes(string modelName,bool showHidden, bool showVisible)
        {
            List<string> meshes = new List<string>();
            TorqueObject model = TorqueObjectDatabase.Instance.FindObject<TorqueObject>(modelName);
            if (model != null)
            {
                T3DTSRenderComponent componentRender = model.Components.FindComponent<T3DTSRenderComponent>();
               
                string mesh = "";
                for (int objectIndex = 0; objectIndex < componentRender.Shape.Objects.Length; objectIndex++)
                {
                    float meshVisibility = componentRender.ShapeInstance.MeshObjects[objectIndex].Visibility;

                    if (showVisible && meshVisibility == 1.0f)
                    {
                        mesh = "MeshName:" + componentRender.Shape.Names[componentRender.Shape.Objects[objectIndex].NameIndex] + "||Visibility:Visible";
                        meshes.Add(mesh);
                    }
                    if (showHidden && meshVisibility == 0.0f)
                    {
                        mesh = "MeshName:" + componentRender.Shape.Names[componentRender.Shape.Objects[objectIndex].NameIndex] + "||Visibility:Hidden";
                        meshes.Add(mesh);
                    }
                }
            }
            return meshes;
        }

    }
    /// <summary>
    /// This class represents the result of a MeshManager call
    /// </summary>
    public class MeshManagerResult
    {
        /// <summary>
        /// This enumeration represents the status of the call
        /// </summary>
        public enum StatusType
        {
            /// <summary>
            /// This means the function call was successful
            /// </summary>
            Success,
            /// <summary>
            /// This means the function call was not successful
            /// </summary>
            Failed
        }
        private string _errorMessage="";
        private StatusType _status;

        /// <summary>
        /// This is populated if the Status = Failed with the proper error message
        /// </summary>
        public string ErrorMessage
        {
            get { return _errorMessage;}
            set { _errorMessage = value; }
        }
        /// <summary>
        /// This Status of the call
        /// </summary>
        public StatusType Status
        {
            get { return _status; }
            set { _status = value; }
        }
    }
}

This can be used in conjunction with the "Extending the Torque X Console" resource found here:

Extending the Torque Console

I put in all my console methods into one class called ConsoleMethods. For instance, to be able to type ShowMesh(modelname,meshname) from the Torque Console (accessed by hitting the ' key), I just added this:

#define TORQUE_CONSOLE
using System;
using System.Collections.Generic;
using System.Text;
using GarageGames.Torque.Core;
using GarageGames.Torque.SceneGraph;
using GarageGames.Torque.Sim;
using GarageGames.Torque.GameUtil;
using GarageGames.Torque.T2D;
using GarageGames.Torque.Platform;
using GarageGames.Torque.GUI;
using GarageGames.Torque.T3D;
using GarageGames.Torque.TS;
using GarageGames.Torque.GFX;
using GarageGames.Torque.Util;

namespace StarterGame3D
{
    /// <summary>
    /// This class encapsulates all the custom methods that can be called from the Torque Console
    /// </summary>
    public class ConsoleMethods
    {

        /// <summary>
        /// This method allows you to turn a meshs visibility on in a model. 
        /// From the command line, you can access it via :  ShowMesh(modelname,meshname)
        /// You do not need quotes to surround the modelname or meshname.
        /// example: ShowMesh(Player,Boots)
        /// </summary>
        /// <param name="error"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public static bool ShowMesh(out string error, string[] parameters)
        {
            error = null;

#if !TORQUE_CONSOLE
            Assert.Warn(false, "Warning: TORQUE_CONSOLE not defined, output won't be displayed!");
#endif
            // Print out all the parameters
            if (parameters.Length == 0)
                TorqueConsole.Echo("No parameters passed into ShowMesh()");
            else
            {
                for (int x = 0; x < parameters.Length; x++)
                {
                    TorqueConsole.Echo("Parameter #" + x + " = " + parameters[x]);
                }
                MeshManagerResult result = MeshManager.ShowMesh(parameters[0], parameters[1]);
                if (result.Status == MeshManagerResult.StatusType.Success)
                {
                    TorqueConsole.Echo(parameters[1] + " is Visible");
                }
                else
                {
                    TorqueConsole.Echo(result.ErrorMessage);
                }
            }
            
            return true;
        }
  }
}

I have a lot more methods defined than that, and some that deal with anmations, such as:

  /// <summary>
        /// This method allows you to play an animation. 
        /// From the command line, you can access it via :  PlayAnimation(modelname,animationName)
        /// You do not need quotes to surround the modelname.
        /// example: PlayAnimation(Player)
        /// </summary>
        /// <param name="error"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public static bool PlayAnimation(out string error, string[] parameters)
        {
            error = null;

#if !TORQUE_CONSOLE
            Assert.Warn(false, "Warning: TORQUE_CONSOLE not defined, output won't be displayed!");
#endif
            // Print out all the parameters
            if (parameters.Length == 0)
                TorqueConsole.Echo("No parameters passed into ShowMesh()");
            else
            {
                for (int x = 0; x < parameters.Length; x++)
                {
                    TorqueConsole.Echo("Parameter #" + x + " = " + parameters[x]);
                }
                TorqueObject model = TorqueObjectDatabase.Instance.FindObject<TorqueObject>(parameters[0]);
                T3DAnimationComponent animationComponent = model.Components.FindComponent<T3DAnimationComponent>();
                Animation animation = animationComponent.GetAnimation(parameters[1]);
                if (animation != null)
                {
                    animation.Play();
                    TorqueConsole.Echo("Playing Animation");
                }
                else
                {
                    TorqueConsole.Echo("Could not find " + parameters[1]);
                }
            }

            return true;
        }

Once you have your ConsoleMethods class, all it takes to be able to call it then is this in your begin run:

            CustomConsoleMethodPool customPool = new CustomConsoleMethodPool();
            customPool.RegisterMethod(ConsoleMethods.ShowMesh);
            customPool.RegisterMethod(ConsoleMethods.HideMesh);
            customPool.RegisterMethod(ConsoleMethods.HideAllMeshes);
            customPool.RegisterMethod(ConsoleMethods.ShowAllMeshes);
            customPool.RegisterMethod(ConsoleMethods.ListMeshes);
            customPool.RegisterMethod(ConsoleMethods.PlayAnimation);
            customPool.RegisterMethod(ConsoleMethods.StopAnimation);
            TorqueConsole.MethodPool = customPool ;

You can then do any type of initialization such as:

            string modelName = "Player";
            MeshManager.HideAllMeshes(modelName);
            MeshManager.ShowMesh(modelName, "Default");

Animations

This took me a while to get going. I originally had every peice , per my last blog, of the player , on seperate layers, aka the default model was spread across 5 layers, and the gear he could use was spread across 5 layers. After doing some research on the various approaches, I think I have found a more common method of doing it. I now have one layer containing a default mesh which is the full body with all parts (head, chest, arms, feet, legs). Then, for the gear he can wear, it still resides on the different layers. Here is the new default testguy:

The other 5 layers house individual peices of equipment, and are colored red. I took this into layout, and added one bone in the chest, as seen here:

Here is the mesh setup in Layout:

With this bone, I created 3 keyframes. At keyframe 0, it was in its rest position. At Keyframe 15, it was rotated horizontally 45 degrees. At KeyFrame 30, it went back to its rest position. This was a very basic animation, and I just wanted to see if I could get it into TorqueX, and then call it. Once I had my basic animation setup, I exported it as a DSQ using our good friend the LW2DTS plugin. I had to use the animation tabs to export the DSQ. One gotcha, is to make sure all your nodes are exported, , as seen below:

And you also have to make sure your objects are used in the sequence, as below:

Once I had the DTS and DSQ, and verified it worked in Torque Showtool Pro, I put it into the game. Here is a shot where the animation is playing, and I show the head mesh (which would realistically be more like a helm or hair) and the model is in its rest pose:

Here you can see it rotating per the animation:

Here you can see the new console method I put in to stop the animation:

Originally, it was only playing one frame, then stopping. After several weeks, and even some correspondence with Andy Hawkins on model setup (his lightwave information is priceless), I figured out that the T3DTSRenderComponent requires an updateanimation call. So on my Player Component, I added a call to updateanimation in the process tick function:

public void ProcessTick(Move move, float dt)
        {
             if (move != null)
            {
                _renderComponent.UpdateAnimation(dt);
            }
        }

In the starter fps demo, they use an animationFSM, but I was just testing a basic animation. Here is the xml for my animation component:

<AnimationComponent type="GarageGames.Torque.T3D.T3DAnimationComponent">
          <SceneGroupName>PlayerMesh</SceneGroupName>
          <Animations>
            <Animation type="GarageGames.Torque.T3D.TSAnimation">
              <ThreadName>ActionThread</ThreadName>
              <SequenceFilename>data\Skeleton\test.dsq</SequenceFilename>
              <Name>Rotate</Name>
            </Animation>
          </Animations>
        </AnimationComponent>

There are some who are having issues having animations run through code only, but that does not surprise me. There seems to be a very heavy focus on having things load through the Torque Deserializer (Like the physic states), which seems like a really odd design choice. I would have thought that you could programmtically setup everything you need without the XML. Then again, I am still new to game engines, so maybe this is how it is supposed to be done.

Summary

I now have my asset creation pipeline functional, and can do basic animations as well as show and hide meshes on demand. I also added some code to handle the toggling of a camera, which was no walk in the park hehe. One thing I noticed was when I switched cameras, I had to make sure it continued to update the animatin, otherwise it would stop. Nonetheless, I have got a lot done, and now with my pipeline defined, and Hiding Mesh class working solid, I am on the right track. I am currently testing John Kanalkis excellent 3d Builder, and will probably attempt to create a generic room, with some artifacts in it as my next step. Until then!

TorqueX - First Stab at Hiding Mesh Resource

David Everhart — 2008-07-09T02:26:50+00:00

When I started to think of character customization, I was doing Arillian in 2D at the time. I used an approach similar to Diablo 2's style. However, per my last blog post, I am now in the 3D world. I looked around, and came upon a resource:

Hiding Meshes resource

I studied it and researched all the pieces it touched. I asked on the forums if anyone had attempted this, but had no replies. I rolled up my sleeves, and decided to take a stab at it. I decided to do a prototype, and see if I could get the meshes to swap in and out at runtime. One of the first questions I had was, how the heck do you build your model? I didnt really know how to go about this , so did some research, and realized I needed a model made up of multiple meshes.

In Lightwave 9, They use layers, like in photoshop. The thought crossed my mind, that maybe I could model the various bodyparts on individual layers, then export the model. I built a basic testman, with 5 layers dedicated to a blue testman, and 5 layers dedicated to a red testman. Below are some pictures.

This picture shows blue feet on layer 1 (Circled in red).

This picture shows blue Legs on layer 2 (Circled in red).

This picture shows all 5 layers for the blue testman (Layers 1-5 circled in red) .

This picture shows all 5 layers for the redtestman (Layers 11-15 circled in red) . The reason the layers arent 6-10 is because I wanted each layer bank (10 layers) to house one character setup. When you export, you can hide the layers with nothing on them .

In all, I used 10 layers. Now I had to export the model to a DTS. Below are some pictures of that:

This picture shows the meshes it found in the model.

The DTSNames are horrible, so I decided to change them, and I had to set each of them to export as a node or mesh, as depicted in the picture above.

When it was all set, the export looked like the above. Now that I had My model, it was time to get the model into the game. I used John Kanalkis's Create Player Function to do just that. I popped it into my game.cs.

public void CreatePlayer() 
        {  
            //create the simple torque object    
            TorqueObject objPlayer = new TorqueObject();
            objPlayer.Name = "CurrentPlayer";
            //create the render component
            T3DTSRenderComponent componentRender = new T3DTSRenderComponent();
            componentRender.ShapeName = @"data\Skeleton\test.dts";      
            //create the scene component    
            T3DSceneComponent componentScene = new T3DSceneComponent();
            componentScene.Position = new Vector3(1024, 1024, 295);
            //add both of the components
            objPlayer.Components.AddComponent(componentRender);
            objPlayer.Components.AddComponent(componentScene);
            //register the object
            TorqueObjectDatabase.Instance.Register(objPlayer);
        }

I added a name to the model, so I can reference it later on. The next step I had to figure out , was how do you actually turn the meshes on and off. Looking at the C++ Hiding resources, it looked like they were manipulating the visibility of the meshes. So after some digging, I found it in the tsShapeInstance class. There is an internal _meshObjects that is an objectinstance[]. I needed to manipulate the meshes in there, so I added a public property to the class.

/// <summary>
        /// Gets and sets the array of meshes for the shape.
        /// </summary>
        public ObjectInstance[] MeshObjects
        {
            get { return _meshObjects; }
            set { _meshObjects = value; }
        }

Now that I had access to the meshes, I needed to be able to control the visibility of them. I decided to group all the related mesh functionality into a class called MeshManager . I decided to make it a static class , although a singleton could have worked as well. It has 5 functions:

ShowMesh(string modelName,string meshName)
HideMesh(string modelName, string meshName)
HideAllMeshes(string modelName)
ShowAllMeshes(string modelName)
ListMeshes(string modelName,bool showHidden, bool showVisible)

Here is the code for it:

using System;
using System.Collections.Generic;
using System.Text;
using GarageGames.Torque.Core;
using GarageGames.Torque.SceneGraph;
using GarageGames.Torque.Sim;
using GarageGames.Torque.GameUtil;
using GarageGames.Torque.T2D;
using GarageGames.Torque.Platform;
using GarageGames.Torque.GUI;
using GarageGames.Torque.T3D;
using GarageGames.Torque.TS;
using GarageGames.Torque.GFX;

namespace StarterGame3D
{
    public class MeshManager
    {

        public static void ShowMesh(string modelName,string meshName)
        {
            SetMeshVisibility(modelName,meshName, true);  
        }

        public static void HideMesh(string modelName, string meshName)
        {
            SetMeshVisibility(modelName,meshName, false);
        }
        public static void HideAllMeshes(string modelName)
        {
            TorqueObject model = TorqueObjectDatabase.Instance.FindObject<TorqueObject>(modelName);
            T3DTSRenderComponent componentRender = model.Components.FindComponent<T3DTSRenderComponent>();

            for (int index = 0; index < componentRender.Shape.Objects.Length; index++)
            {
                componentRender.ShapeInstance.MeshObjects[index].Visibility = 0.0f;
            }
        }
        public static void ShowAllMeshes(string modelName)
        {
            TorqueObject model = TorqueObjectDatabase.Instance.FindObject<TorqueObject>(modelName);
            T3DTSRenderComponent componentRender = model.Components.FindComponent<T3DTSRenderComponent>();
            for (int index = 0; index < componentRender.Shape.Objects.Length; index++)
            {
                componentRender.ShapeInstance.MeshObjects[index].Visibility = 1.0f;
            }
        }


        private static void SetMeshVisibility(string modelName, string meshName, bool visible)
        {

            TorqueObject model = TorqueObjectDatabase.Instance.FindObject<TorqueObject>(modelName);
            T3DTSRenderComponent componentRender = model.Components.FindComponent<T3DTSRenderComponent>();
            for (int objectIndex = 0; objectIndex < componentRender.Shape.Objects.Length; objectIndex++)
            {
                if (componentRender.Shape.Names[componentRender.Shape.Objects[objectIndex].NameIndex].ToUpper() == meshName.ToUpper())
                {
                    if (visible)
                    {
                        componentRender.ShapeInstance.MeshObjects[objectIndex].Visibility = 1.0f;
                    }
                    else
                    {
                        componentRender.ShapeInstance.MeshObjects[objectIndex].Visibility = 0.0f;
                    }
                }
            }
        }

        public static List<string> ListMeshes(string modelName,bool showHidden, bool showVisible)
        {
            TorqueObject model = TorqueObjectDatabase.Instance.FindObject<TorqueObject>(modelName);
            T3DTSRenderComponent componentRender = model.Components.FindComponent<T3DTSRenderComponent>();
            List<string> meshes = new List<string>();
            string mesh = "";
            for (int objectIndex = 0; objectIndex < componentRender.Shape.Objects.Length; objectIndex++)
            {
                float meshVisibility = componentRender.ShapeInstance.MeshObjects[objectIndex].Visibility;

                if (showVisible && meshVisibility == 1.0f)
                {
                    mesh = "MeshName:" + componentRender.Shape.Names[componentRender.Shape.Objects[objectIndex].NameIndex] + "||Visibility:Visible";

                    meshes.Add(mesh);
                }
                if (showHidden && meshVisibility == 0.0f)
                {
                    mesh = "MeshName:" + componentRender.Shape.Names[componentRender.Shape.Objects[objectIndex].NameIndex] + "||Visibility:Hidden";
                    meshes.Add(mesh);
                }
            }
            return meshes;
        }


    }
}

It doesnt have all its exception handling, and is not fully refactored yet,but for my prototype, that is ok. Now that I have a meshmanager, I decided to test it by putting this in my begin run:

MeshManager.HideAllMeshes("CurrentPlayer");
MeshManager.ShowMesh("CurrentPlayer", "RedFeet");
MeshManager.ShowMesh("CurrentPlayer", "RedLegs");
MeshManager.ShowMesh("CurrentPlayer", "RedTorso");
MeshManager.ShowMesh("CurrentPlayer", "RedArms");
MeshManager.ShowMesh("CurrentPlayer", "RedHead");

The result is below:

I hid all the meshes initially for the CurrentPlayer Object, then showed the 5 red meshes. Now, in order for me to test the functionality of the other functions, I wanted to use the console. In order for me to call custom methods from the torqueX console (accessed via ~), I had to extend it, with this great resource:

Extending the TorqueX Console

Once I implemented that, I added a class to handle all the custom methods , so that I could call them directly from the console.

Here I hide the Red head mesh, with a HideMesh call.

Now I show the Blue head mesh, with a ShowMesh call.

In the above picture, I list all the meshes and their current state.

The next step for me, is to create some basic animations, and test how the meshes react when switching on and off in an animation. Ok, its been a loooong post, so I will post the results of the animation one when I am done. Until then!

Journey Into 3D

David Everhart — 2008-06-22T05:09:45+00:00

It has been about six months since my last post, and a lot has happened with my development of Arillian. I was going pretty strong in my 2d development of Arillian, but it was very time consuming, and the optimization required for the approach I required I dont think would work well with XNA and by extension TorqueX (maybe pure directx though) .

In Diablo 2, they would stuff a character animation in 32 directions, into a roughly 80kb file. They would then blit it to the screen , similar to the XNA spritebatch render. Although I got my process to do something similar, it was still around 100 milliseconds, and the file sizes in XNA were getting fairly large. I also had a dependence on art assets from others.

After reviewing Titans Quest and Mythos Overworld a little more in depth, and having read some of the Diablo 2 developer comments, in addition to my above concerns, I have come to the conclusion that 3D is truly the way to go. With that in mind, I stopped my 2d development on Arillian. However, due to the way I set it up, I can still use the core engine peices I have built to date. From this point, I decided I needed to do the following:

1) Identify the New Pipeline
2) Choose a 3d Program that supports the pipeline
3) Learn the 3d program
4) Build a simple character, export via dts into the TorqueX engine

Identifying the new pipeline

The first thing I did was try to identify the new art pipeline. I asked on the 3D modeling forum about that, and got some good replies. From what I gather, the pipeline looks like:

1) Model
2) Texture
3) Rig
4) Animate
5) Export to DTS/DSQ

Choose a 3D Program

I then began to look at the various 3D packages that might support that. I tried the following:

1) 3DSMax - Apparently this is the big daddy of all 3d packages. I tried the evaluation, and even bought several good books on it, and did online research on it. I liked the interface, but the price tag makes this unavailable to me.

2) Maya PLE - Similar to 3DSMax, eexcept I didnt buy any books for it. I really liked the interface of it as well. The price makes this unavailable to me as well.

3) MilkShape - I tested this out, but didnt care too much for the interface. Sometimes there are programs that you just get a feeling about, and I didnt have a good one with milkshape, maybe it was because I had evaluated 3DSMax and Maya PLE before this.

4) XSI Foundation - I liked this one as well. The interface took some getting used to, but in order to get the full suite of functionality, you had to get the upgrade. The foundation though looked like it would be the only thing required for the level of stuff I needed to do. All that for 500$, this was the first one I found that I might actually spend time on and use.

5) LightRay 3D - I didnt like the interface. I have heard good things about this program, but it did not stick well with me. To be fair though, I did not give it as much time as the others.

6) LightWave - This was the last one I tested. I had Blender , Modo, and AC3D (suggestion from a poster) up for testing as well. Something stuck with me on Lightwave. The interface to me was intuitive. The list of features would let me handle the above pipeline, and they had a very robust DTS exporter (by Gnometech).

Learn the 3D Package

I chose Lightwave out of my 5 month evaluation period of the various programs. I have learned quite a bit about it, and the hotkeys have become second nature to me so far. The showtool was also written with a lightwave like interface. I downloaded the trial, and bought :

Essential Lightwave 9

The video tutorials are excellent, and I learned about the various approaches to 3D modeling at a high level:

1) Polygonal Modeling
2) Spline Modeling
3) SubDivision Modeling
4) MetaBall modeling

I did my first model with purely polygonal modelng approaches via the video tutorial :

I am currently learning about the spline modeling approaches. The thing that I really liked about this book and in particular Steve Warners website,was that the it explains things fairly well. I assumed that when modeling, you used one approach, and only one approach, I now understand that you can use a variety of modeling approaches, on the same model, dependent on the situation. There is a ton to learn, I am only on chapter 8 , and there are 27 chapters, and tons of video tutorials. I also picked up Dan Ablans book on Lightwave, and will go through that one as well when I am done with Steve Warners.

There seems to be a very strong lightwave community out there, and I even found some good links here on the Torque site, such as Andy Hawkins post here:

Lightwave Rigging

If the URL fails for whatever reason, the url is:

http://www.garagegames.com/index.php?sec=mg&mod=resource&page=view&qid=10098

Build a simple character, export via dts into the TorqueX engine

My current goal, including learning Lightwave , is to build a simple character, do some basic animations, export it to DTS/DSQ, then import it into Torque X. Once this basic peice is working, I want to see if I can implement a C# version of the hiding meshes resource:

Hiding Meshes resource

The Hiding Meshes approach looks exactly what I want to do for character customization.After I get the basic flow down for creating and exporting/importing, I will begin to work on this. I understand the basics of whats happening in the code , but am unsure of how the setup of nodes, mounts, and the like is setup in Torque X. The character I am building will be a block man for testing purposes. I dont know if I need a segmented model, a continous one with parts defined, or what not. I will figure it out in time.

One thing that I want to make clear, is this will still be a isometric viewed game. I want to implement the game as a 3d world, but use a isometric camera view for the game, similar to titans quest and mythos overworld. Ok, Thats a lot of writing :) Until the next update!!

TorqueX Newbie Diary #6

David Everhart — 2008-01-28T09:29:53+00:00

Quite a bit has been done on Arillian since the last update. The main advances have been:

1) Introduction of another animation
2) Revamp of the project setup
3) Revamp of the animation system
4) Animation change based on mouse

Introduction of another animation

In order to test out animation transition, and the action that causes it, I needed another animation. I already had one for a human male in an idle mode with no weapons facing south. I went to my trusty poser 7 and used the same mode, but this time, rendered it southwest. One thing to note, I do not include shadows, since I will be implementing shadows runtime based on light sources.

Revamp of the project setup

I restructured my project by moving out the peices to logical projects. I now have the following projects in my solution:

1) DataAccess - Persistence layer, provides access to a persistance engine (in my case, Sql Server 2005 Express)
2) AnimationManagement - This project handles all the animation creation and management
3) Common - Anything that is common to all the projects, or needs to be access globally.
4) ArillianGameEngine - This project handles all the core Arillian classes, such as Player, ItemManager, etc
5) Game - The basic project that the startertemplates use, it is still used as the starting point

Revamp of the animation system

I was unhappy with the file naming system I had originally used. Although Diablo II used a similar format for naming, it felt hackish to me. I went ahead and implemented a data model in sql server 2005 express to persist the animation information, as well as all game related information (such as login , accounts, saved games, configuration, etc). This allowed me to run stored procedures (that take around 5- 10 milliseconds) to grab animation layer information. Since my AnimationLayers have IDs now, My file system now has folders related to the ID.

Fo example, The root folder to the animationlayers is constant (C:\Projects\Arillian\Game\data\Images\AnimationLayers). Inside that folder are folders called 1, 2, 3, 4, etc. They correspond to the AnimationLayerID. Inside those folders are the frames for that animation layer. If you recall, an AnimationLayer is just one layer for an animation configuration. The animation configuration for any player is always 4 animation layers (head, torso, lefthand, righthand).

My Player object has one animated sprite, which I was hoping to just swap in and out the animation datas. Unfortunately, I do not think TorqueX was really designed for that. So I implemented a solution around it. I still have the animated sprite definition in my Player object, but now I copyto() a new animated sprite, attach the animation, and then run it from there. I maintain the object id of the current sprite in the TorqueObjectDatabase, so I can unregister it, and then register the new one, and set the current id. Here is my Player.UpdateAnimation() function so far:

  public void UpdateAnimation()
        {
            DateTime startTime = DateTime.Now;
            Console.WriteLine("UpdateAnimation::Start Time is " + startTime.ToLongTimeString());
            // Get the Current Camera
            T2DSceneCamera currentCamera = (T2DSceneCamera)TorqueObjectDatabase.Instance.FindObject("Camera");

            // Get the AnimationConfiguration
            AnimationConfiguration configuration = GetAnimationConfiguration();

            // Make sure we have 4, if we dont, then the AnimationConfiguration is not valid
            if (configuration.AnimationLayers.Count == 4)
            {
                // Get the T2dAnimationData
                T2DAnimationData animationData = AnimationManager.Instance.CreateT2DAnimationData(configuration, ImageFormat.Png);

                // Check to see if the current sprice has an ID, default is -1
                if (currentSpriteId > -1)
                {
                    // Unmount the Camera
                    currentCamera.Dismount();
                    // Unregister it
                    TorqueObjectDatabase.Instance.Unregister(TorqueObjectDatabase.Instance.FindObject((uint)currentSpriteId));

                }
                // Create a new copy based off our _sprite definition
                T2DAnimatedSprite spriteCopy = new T2DAnimatedSprite();
                _sprite.CopyTo(spriteCopy);

                // Set the new animation data
                spriteCopy.AnimationData = animationData;

                // Setup our Sprite
                TorqueObjectDatabase.Instance.Register(spriteCopy);
                currentSpriteId = Convert.ToInt32(spriteCopy.ObjectId);
                currentCamera.Mount(spriteCopy, "", true);

                // Play the new animation
                spriteCopy.PlayAnimation();
            }

            DateTime endTime = DateTime.Now;
            Console.WriteLine("UpdateAnimation::End Time is " + endTime.ToLongTimeString());
            TimeSpan timeToRun = endTime.Subtract(startTime);
            Console.WriteLine("UpdateAnimation::Time to run is " + timeToRun.TotalMilliseconds.ToString());
        }

When the code runs, this is how long it takes to compress 60 frames (4 animation layers * 15 frames each), draw a shadow on each cell of the final image (I do this runtime, as opposed to baking it in the image), render it to T2DAnimationData, and then attach it to the newly copied animated sprite:

UpdateAnimation::Start Time is 3:01:17 AM
UpdateAnimation::End Time is 3:01:17 AM
UpdateAnimation::Time to run is 234.375

Now, when I run this, I cache the animation layer in a Dictionary<int,Image>. The int is the animation layer id, and the image is the animation layer image. When the animation is cached, it will use the image from there, instead of rerendering the 15 frames. Here is a cached pull:

UpdateAnimation::Start Time is 3:01:19 AM
UpdateAnimation::End Time is 3:01:19 AM
UpdateAnimation::Time to run is 78.125

There is no noticeable lag in animation switching. Bear in mind, the time to run is in milliseconds. I am happy with the speed of it, but do not know yet how it will perform when a lot of things are moving on the screen. The below code is the check to see if it is cached, and if is not, to cache it.

                    Image imageToMerge;
                    if (AnimationManager.Instance.AnimationLayerImages.ContainsKey(newAnimationLayer.ID))
                    {
                        // Load from cache
                        AnimationManager.Instance.AnimationLayerImages.TryGetValue(newAnimationLayer.ID, out imageToMerge);
                    }
                    else
                    {
                        // Load from file
                        imageToMerge = CreateAnimationImageStrip(newAnimationLayer);
                        // Store it for future use if it isnt already cached
                        AnimationManager.Instance.AnimationLayerImages.Add(newAnimationLayer.ID, imageToMerge);
                    }

Animation change based on mouse click position

I first wanted to use a button to test my animation change, but realized I would have to figure out the new 1.5 GUI setup. Instead , I decided to implement the mouse functionality. I have some guidelines on what I want the mouse to do in regards to the player. They are:

1) If the Shift button is held down, mouse clicking anywhere on the screen will have the player face that direction
2) If the shift button is not held down, and they are within a distance of 50, then perform the walk animation and move the player in that direction
3) If the shift button is not held down, and they are over a distance of 50, then perform the run animation and move the player in that direction

I implemented ITickOBject on my custom player class, and in the process tick, handle the mouse. I have not integrated the distance or shift peices yet, but have implemented the change direction based on angle of mouse click or drag.Code is below:

  public void ProcessTick(Move move, float dt)
        {
            // Get the current Mouse State
            MouseState state = Mouse.GetState();
            if (state.LeftButton == ButtonState.Pressed) // Means button was pressed
            {
                // Get the Mouse coordinates
                Vector2 mouseCoordinates = Utility.ConvertScreenToWorld(new Vector2((float)state.X, (float)state.Y), Configuration.Instance.ScreenResolution);
                // Figure out what the angle is in relation to the player
                float angle = T2DVectorUtil.AngleFromTarget(mouseCoordinates, Player.Instance.Sprite.Position);
                // Convert it to an enumeration we can use 
                Enumeration.Direction newDirection = Utility.ConvertAngleToDirection(angle);
                // Check to see if we need to do anything
                if (newDirection != Player.Instance.Direction)
                {
                    //Console.WriteLine(newDirection.ToString());
                    float distance = Vector2.Distance(mouseCoordinates, Player.Instance.Sprite.Position);
                    Player.Instance.Direction = newDirection ;
                    Player.Instance.UpdateAnimation();
                }

            }
        }

This allows me to capture even mouse drag events, so you can literally mousedrag a circle around the player, and it will only fire if the angle is between certain ranges. You can also click, and it will do a check as well (Thanks to John Kanalkis for the idea, and Josh Thomas for the screen to world conversion function.).

Summary

Here are two screenshots of the south idle and southwest idle animations:

Facing South:

Facing SouthWest:

Its been a long and fun road so far, a lot more to go. With Poser 7, I am finally feeling comfortable in it, and can whip out renderings pretty easy. I am still learning the animation aspects of it though. The world is comng along, thanks to WorldCreator 2.5 as well. My next steps are to render out the 8 direction for the idle, walking, and running animations. I also want to get it so that you can move the player around like in Diablo. I am close to it now, the mechanics are there, I just need to flush it out. With the inclusion of a database, I now have a persistence layer I am very familiar with, so that should speed things up as well. Until the next update!

TorqueX Newbie Diary #5

David Everhart — 2008-01-07T15:44:22+00:00

Well, I had a real long post written out, going into some pretty low level detail, but it seems this site has eaten that blog.... This time I will save off my post. Nonetheless, below is a screenshot of the start of my starting area, Ruston Post. It has only been 1.5 months since I started working from ground zero (literally), so be gentle!

The tiles are done in WorldCreator 2.5, and the character is done in Poser 7. I have got the import process from WorldCreator to TGBX down pretty tightly. I had some problems initially though. TGBX seemed to want to keep displaying a thin border around all my transparent PNGs. I finally discovered that I needed to:

1) Save the WorldCreator files to a transparent gif
2) In adobe photoshop, convert it to RGB mode
3) Layer->Matting->Remove White Matte
4) Layer->Matting-> Remove Black Matte
5) Layer->Matting->Defringe (I used 2 pixels).
6) Save as web for a transparent PNG-24

I have to do this process for each tile, so TGBX wont render a border around the transparent png. So far it seems to work, as the screenshot above shows. Another issue I ran into was that the default tilemap object does not work too well with truly 2:1 isometric tiles. You can generate a top down 2D tile, then rotate the tilemap object 60 degrees, but the look is definitely not isometric (think that is called trimetric, not sure). I ended up placing them as static sprites, at layer 30. If it becomes a performance issue, I will write my own isometric tiling system in XNA.

I am amazed at the power WorldCreator has. It uses masks, which are color coded, and can render in top 2, isometric floor, isometric walls, etc. Once I figured out how to work in it, and then how to export from it to TGBX, creating new content for Arillian became not only feasible, but fairly painless. In the screenshot above, I have a dirt road tile, a grass tile, a tower item, and an archway. Each of them took less than a minute roughly to create, but it was the export into TGBX that was holding me up. With that out of the way, my environment creation pipeline should be much more efficient!

The character was done using Poser 7.0. I am using the Michael 3.0 Base, with muscular body morphs, and the honor bound light armor set. In Arillian, there are three types of armor, light, medium, and heavy. Each type has several visual styles, and the one above is a light armor. Although you cant see it above in the screenshot, he is doing an idle animation, and I rendered out the animation from Poser 7.0 as 10 frames.

The character you see above is the final product of an AnimationConfiguration being processed. The AnimationConfiguration class contains a List<AnimationLayer>. Each AnimationLayer contains how many frames it needs, and attirbutes which help it to get the frames from where they are stored locally. The character above uses an AnimationConfiguration with 4 AnimationLayers. In my testing, I manually create the layers, though in reality the generation of the animation layer will be handled automatically.

 AnimationConfiguration newConfiguration = new AnimationConfiguration();
            newConfiguration.T2DAnimationDataTemplate = Enumeration.T2DAnimationDataTemplate.DefaultCharacter;
            newConfiguration.ID=1;
            AnimationLayer headLayer = new AnimationLayer();
            headLayer.AnimationType = Enumeration.AnimationType.Character;
            headLayer.Race =Enumeration.Race.Human;
            headLayer.Gender = Enumeration.Gender.Male;
            headLayer.AnimationLayerType = Enumeration.AnimationLayerType.Head;
            headLayer.ItemToken = "LIT";
            headLayer.Mode = Enumeration.Mode.TownNeutral;
            headLayer.WeaponClass = Enumeration.WeaponClass.HandToHand;
            headLayer.Direction = Enumeration.Direction.South;
            headLayer.FrameCount = 10;
            headLayer.FormatOfImage = ImageFormat.Png;
            headLayer.Sort = 2;
            newConfiguration.AnimationLayers.Add(headLayer);

From this, I can generate the path as data/globals/character/human/male/LITTNHTHSO. Since there are 10 frames and the format is png, it will get data/globals/character/human/male/LITTNHTHSO_1.png to data/globals/character/human/male/LITTNHTHSO_10.png. It then creates a horizontal strip out of the frames. Here is the full code to render the character above:

  public static void CreateAnimation()
        {
           
            AnimationConfiguration newConfiguration = new AnimationConfiguration();
            newConfiguration.T2DAnimationDataTemplate = Enumeration.T2DAnimationDataTemplate.DefaultCharacter;
            newConfiguration.ID=1;
            AnimationLayer headLayer = new AnimationLayer();
            headLayer.AnimationType = Enumeration.AnimationType.Character;
            headLayer.Race =Enumeration.Race.Human;
            headLayer.Gender = Enumeration.Gender.Male;
            headLayer.AnimationLayerType = Enumeration.AnimationLayerType.Head;
            headLayer.ItemToken = "LIT";
            headLayer.Mode = Enumeration.Mode.TownNeutral;
            headLayer.WeaponClass = Enumeration.WeaponClass.HandToHand;
            headLayer.Direction = Enumeration.Direction.South;
            headLayer.FrameCount = 10;
            headLayer.FormatOfImage = ImageFormat.Png;
            headLayer.Sort = 2;
            newConfiguration.AnimationLayers.Add(headLayer);

           
           
            AnimationLayer torsoLayer = new AnimationLayer();
            torsoLayer.AnimationType = Enumeration.AnimationType.Character;
            torsoLayer.Race = Enumeration.Race.Human;
            torsoLayer.Gender = Enumeration.Gender.Male;
            torsoLayer.AnimationLayerType = Enumeration.AnimationLayerType.Torso;
            torsoLayer.ItemToken = "LT1";
            torsoLayer.Mode = Enumeration.Mode.TownNeutral;
            torsoLayer.WeaponClass = Enumeration.WeaponClass.HandToHand;
            torsoLayer.Direction = Enumeration.Direction.South;
            torsoLayer.FrameCount = 10;
            torsoLayer.FormatOfImage = ImageFormat.Png;
            torsoLayer.Sort = 1;
            newConfiguration.AnimationLayers.Add(torsoLayer);

            AnimationLayer leftHandLayer = new AnimationLayer();
            leftHandLayer.AnimationType = Enumeration.AnimationType.Character;
            leftHandLayer.Race = Enumeration.Race.Human;
            leftHandLayer.Gender = Enumeration.Gender.Male;
            leftHandLayer.AnimationLayerType = Enumeration.AnimationLayerType.LeftHand;
            leftHandLayer.ItemToken = "LIT";
            leftHandLayer.Mode = Enumeration.Mode.TownNeutral;
            leftHandLayer.WeaponClass = Enumeration.WeaponClass.HandToHand;
            leftHandLayer.Direction = Enumeration.Direction.South;
            leftHandLayer.FrameCount = 10;
            leftHandLayer.FormatOfImage = ImageFormat.Png;
            leftHandLayer.Sort = 1;
            newConfiguration.AnimationLayers.Add(leftHandLayer);

            AnimationLayer rightHandLayer = new AnimationLayer();
            rightHandLayer.AnimationType = Enumeration.AnimationType.Character;
            rightHandLayer.Race = Enumeration.Race.Human;
            rightHandLayer.Gender = Enumeration.Gender.Male;
            rightHandLayer.AnimationLayerType = Enumeration.AnimationLayerType.RightHand;
            rightHandLayer.ItemToken = "LIT";
            rightHandLayer.Mode = Enumeration.Mode.TownNeutral;
            rightHandLayer.WeaponClass = Enumeration.WeaponClass.HandToHand;
            rightHandLayer.Direction = Enumeration.Direction.South;
            rightHandLayer.FrameCount = 10;
            rightHandLayer.FormatOfImage = ImageFormat.Png;
            rightHandLayer.Sort = 1;
            newConfiguration.AnimationLayers.Add(rightHandLayer);
            

            AnimationManager.Instance.AnimationConfigurations.Add(newConfiguration);

            DateTime startTime = DateTime.Now;
            Console.WriteLine("CreateAnimation StartTime is " + startTime.ToLongTimeString());

            DrawAnimationConfiguration(1, new Microsoft.Xna.Framework.Vector2(4, 10));

            DateTime endTime = DateTime.Now;
            Console.WriteLine(" CreateAnimation End Time is " + endTime.ToLongTimeString());
            TimeSpan timeToRun = endTime.Subtract(startTime);
            Console.WriteLine("CreateAnimation Time to run is " + timeToRun.TotalMilliseconds.ToString());

        }

Thats a lot of code, but once its tied into the player, it will be autogenerated. For now, I typed it out for testing purposes. There is a lot going on there, but the total time from scratch is around 250 milliseconds. My initial cache testing showed under 100 milliseconds, but I am still testing that.
This is the test drawing code:

 public static void DrawAnimationConfiguration(int configurationID, Vector2 position)
        {
            AnimationConfiguration newAnimationConfiguration = AnimationManager.Instance.AnimationConfigurations.Find(delegate(AnimationConfiguration animationConfiguration) { return animationConfiguration.ID == configurationID; });
            T2DAnimationData testData = AnimationManager.Instance.CreateT2DAnimationData(newAnimationConfiguration, ImageFormat.Png);
            // setup our animation sprite
            T2DAnimatedSprite newSprite = new T2DAnimatedSprite(testData);
            newSprite.Position = position;
            newSprite.Folder = TorqueObjectDatabase.Instance.CurrentFolder;
            newSprite.Visible = true;
            newSprite.Layer = 0;
            newSprite.Name = "test" + configurationID.ToString();
            newSprite.Size = new Vector2(20);
            

            // this is for test purposes
            //newSprite.OnFrameChange =  delegate(int frame) { Console.WriteLine(frame.ToString());};
            if (newSprite.IsRegistered)
            {
                TorqueObjectDatabase.Instance.Unregister(newSprite);
            }
            TorqueObjectDatabase.Instance.Register(newSprite);
            newSprite.PlayAnimation();
        }

I have also been studying and learning 3DSMax, and bought the 3dsMax official learning guide book. I am roughly halfway through it, there is a lot to learn. I am continuing to learn it because although Poser 7.0 is powerful, I may need the raw power of 3dsmax to do what I need at times. The fact they did all the animations and design for the barbarian in Diablo 2 in 3ds max tells me it is very powerful in that regard. Ahh well, so much to learn, and much more to do. Next update, I hope to have the starting area completed, and character movement working (along with the walking animation). Until Then!

TorqueX Newbie Diary #4

David Everhart — 2007-12-12T03:07:58+00:00

Well, this has been a busy period , but I have been able to make a lot of strides recently. I am currently learning Poser 7,3DSMax, and WorldCreator. I am thinking that my toolset will be:

Poser 7 - character animation sprite maps
3DSMax - Prop creation (clothes, weapons, etc)
Photoshop - sprite strip maker
WorldCreator 2.5 - Tiles, Environment, World Objects (awesome 2D world engine)
TorqueX 1.5 - Game Engine

I am still learning on all of them minus photoshop which I have used for the last 5 years.

Animation Creator

I have retooled the AnimationCreator and stripped it down to several classes. I now have an AnimationLayer class, which BodyAnimationLayer inherits from, and ItemAnimationLayer inherits from BodyAnimationLayer. The AnimationManager singleton can cache them, preload animation layers, and of course merge them into a T2DAnimatedData, and then cache it for reuse. I also have an AnimationHelper which has generic image support functions and an AnimationConfiguration class which houses a configuration of animation layers(both body and item). I was also able to get the T2dAnimationData conversion working like a champ (Thanks to John Kanalkis). The 1.5 release offered a SimpleMaterial object that allowed me to set my texture directly.

I realized halfway through developing it, that I only really will use imagestrips. That is what the animation layer is, literally, just a class that houses the image path, an ID, and a sort. The Body Animation Layer inherits from that, and has 4 variables: Race, Mode, WeaponClass, and Direction. Regardless of the character animation, every single frame requires this essential set of 4 variables, hence they are put in a class. The Item Animation Layer inherits from the Body Animation Layer and adds Item specific things, such as the Itemtype.

I have figured for my testing purposes, I will use 1 Race , that being Human for now For the modes, I have defined them as :

  public enum Mode
        {
            Attack1 = 1,
            Attack2 = 2,
            Attack3 = 3,
            Block = 4,
            CautiousIdle = 5,
            Cast = 6,
            GetHit = 7,
            Idle = 8,
            Kick = 9,
            Run = 10,
            Walk = 11
        }

These modes represent the action that is occuring. For example, a character can be attacking, blocking, idling, casting, running, etc. You get the idea. Each one of those modes causes the animation to behave differently. For my WeaponClass, the values are:

   public enum WeaponClass
        {
            Bow = 0,
            ClawsAndShield = 1,
            CrossBow = 2,
            DualClaws = 3,
            HandToHand = 4,
            HandAndShield = 5,
            OneHandedSwing = 6,
            OneHandThrust = 7,
            LeftSwingRightSwing = 8,
            LeftSwingRightJab = 9,
            LeftJabRightSwing = 10,
            LeftJabRightJab = 11,
            Staff = 12,
            TwoHandedSwing = 13,
            TwoHandedThrust = 14
        }

These weaponclasses further represent how the animation needs to play by defining the way they hold the weapons (a staff is different from a claw for instannce) . The last of the four is direction, which is pretty easy to define:

  public enum Direction
        {
            South,
            SouthWest,
            West,
            NorthWest,
            North,
            NorthEast,
            East,
            SouthEast
        }

So to do an example, you could have a human that is running, with dual swords, and headed Southeast. If you figure (for my test), 1 race, 11 modes , 14 weaponclasses, and 8 directions, thats a ton of sprites (1232 to be exact). However, we know that we can flip at least 3 of them, so now we are down to 5 directions (770 sprites). Keep in mind, this is only for a naked character with no armor or weapons. Now in my preload, I only load the configuration (not the images). The images are merged on demand, then cached. I am still unit testing this at the moment and will get some numbers on the runtime merge(I am thinking less than a 100 milliseconds more than likely based on my past tests). Since I have optimized the code some, It should be pretty quick.

As for the Armor and Weapons, those all have the same as the body, but I can reuse a lot of the same strips. For instance, the helm strip for a human running with dual swords southeast is the same for a human walking with dual swords goung southeast. Also, if a character is only switching weapons, the animation that is cached only really needs to change one peice of it, so caching the animation in various merge states is ideal (Aka cache the body, then cache the body with armor on, then cache the body with armor and weapons). That way if they switch weapons, we just call the second one we stored, swap in the new itemanimationlayer, merge, recache, and we are on our way. This can be also based on what I think will change the most. For instance, gloves usually get swapped more than say a chest peice.

Core Game Objects

I have also created a Player singleton, that houses (for the moment) an Equipment Object that houses everything he is wearing. It will manage the state of the player , and also contain a List<InventoryItem>. I also built an ItemManager singleton, that stores Items. I have a base Item class, and classes that inherit from it like EquippableItem have inventory images, a List<ItemAnimationLayer>, etc. I can actually pass a BodyAnimationLayer to the List<ItemAnimationLayer> in the item and have it pull out the correct Item animation layer.

public ItemAnimationLayer GetAnimation(BodyAnimationLayer bodyLayer)
        {
            return _itemAnimationLayers.Find(delegate(ItemAnimationLayer itemlayer) { return itemlayer.BodyLayer.Equals(bodyLayer); });
        }

The ItemLayer exposes a reference to the baseclass for searching purposes. Well, looks like I have written a ton of stuff. I will continue learning on Poser 7, WorldCreator 2.5, 3DS Max, and of course our good friend Mr Torque X 1.5. Until then!!

TorqueX Newbie Diary #3

David Everhart — 2007-12-07T02:36:35+00:00

Animation Creator

Well, after spending a lot of time with the torquex 3d stuff, I have decided to instead spend some more time trying out some 2D approaches. As such , I began researching 2d character itemization techniques. There was a lot of basic information out there, but most of it was not too helpful. Techniques ranged from swapping out channels, to writing the individual peices to the screen as individual peices, held together by a logical representation of the base object.

I tried the second approach somewhat, but mounting a helm animation, chest animation, leg animation, boot animation, weapon animation, etc adds up, and thats just ONE direction. If your animations were 10 frames per animation, your looking at around 100+ easily for a complex animation. While these are definitely viable, they just dont seem to practical to me. After some more research, I came upon this:

Diablo II's Animations

Paul Siramy in his excellent pdf went through how Diablo II did their character itemization, even down to the file formats, structure, and how it all comes together. They used a technique where they applied images (sprites) into frames at runtime, then meshed them all together for one final animation. In his pdf, he explains how they basically have body parts, weapons, and items, and can literally adjust the tint (via a colormap) to create new versions of an existing item . The neat thing about this approach,is you only deal with the final animation, versus say 10 T2dAnimatedSprites mounted to each other.

With all that in mind, and after dissecting that pdf over many smoke breaks, lunches, late night reading, and good old fashioned bathroom reading material, I decided to build my own. I first checked out XNA support for Texture2D. It seemed pretty lacking, and although you can render a texture to another texture, it doesnt seem like it was really built for manipulating images. My next technology I looked at was GDI+, something I have worked with extensively in the past. I know it has very robust image handling capabilities, but the downside is it does not run on Xbox 360 (which is fine for me). Windows Presentation Foundation is a little too far in the future for me to really use (although I can see it will be a powerhouse when .NET 3.0 is used everywhere). With all that in mind, I chose GDI+, with the mindset that the logical structure of my AnimationCreator library wont change much, although the underlying image manipulation might.

At a high level,the rough prototype I have now basically merges images into a frame, and then merges frames into a framelayer, and then finally merges framelayers into an animation. There is also an AnimationDatabase singleton, allowing you to cache your animations, framelayers, and spritesheets if you have any. and call them at will. I also built the prototype so you can load a spritesheet directly to a framelayer (you use a List<FrameDefinition> to specify how to slice it up, any colormaps, etc).

The goal was to be able to produce that final animation image. This image is then converted to a DefaultEffect, then passed in as the material for a T2dAnimationData object. In essence, you can literally build either frame by frame, or whole frame layers at once, or anywhere inbetween, and come out with an animation that takes around 200 milliseconds so far to create. You can also apply colormaps at the frame, framelayer, or animation level.

A good example of the flexibility I am aiming for is that you could, at runtime, get an animation you created already via the AnimationDatabase, and then change the 7th frame of the helm frame layer if you wanted to. I wanted it so you can literally touch any frame or framelayer in the animation, then rebuild the animation on the fly.

I am having some issues with the defaulteffect aspect of the Torque engine however,and I may just need to create my own effect to support this (I hope not). The current effects assume you have an asset or a file, but no real stream support. It does have some functionality allowing you to change the base texture of an already loaded one, but my tests have not been successful as of yet(nor have I got a response from the forums). I will post it once it is cleaned up , has a lot more validation, and has been optimized. Since it is a seperate project, you can just drop in the binary or add the project once its done, and of course, I will provide it to anyone that wants it. Until next time!

TorqueX Newbie Diary #2

David Everhart — 2007-12-01T06:34:50+00:00

Well, it has been an eventful last few days. I continued working on the Main menu GUI aspects of Arillian, and also dabbled in other areas. I have a ton to learn.

GUIBitmapButton and Mouse click event

I came across a problem trying to get my GUIBitmapButtons to register a mouse click. At first I figured I didnt read through the code correctly , so spent quite a bit of time seeing how the inputmanager class works. I still was not able to figure out how to bind a mouseclick to the GUIBitmapButton I had on my main menu. The BindAction that was used for the keyboard and gamepad didnt seem to work with the mouse.

After thinking about it, I decided to roll my own. I have done a first pass, by extending the GUIBitmapButton to expose a delegate for the mouse click event. I also implemented the ITickObject interface , and in the ProcessTick, I check the current mouse position, against the bounding box of the button. If it is in the bounds, and the mousebutton state is pressed, I fire off the delegate. I also set the focus to the control at that point. That works like a champ. However, I only wanted it to do the mouse checking when the button is "awake". So I overrode the OnWake function and registered it with the ProcessList, and then I overrode the OnSleep function, so it can be removed.

For my second pass, I think I am going to inherit from the GUIBitMapButton, maybe call it GUIBItmapEnhancedButton, and put all my modifications into that. That way I can use the stock one or my enhanced version. I am thinking I will add another texture for the pressed down state, and also expose a onMouseHover delegate.

Level State Machine

I went through the TorqueCombat Level State Machine code, and it provided some good insights. I used to think of the .txscene files loaded by the sceneloader were "levels" so to speak. However, in their example, they actually create the level through code, and populate it with what is needed. The .txscene file looks like it has everything in it, and it is pulled out as needed. I am thinking I may still want to go with the level per .txscene, especially if I am looking at a possible 3d environment (not fully sure at the moment). I am still going through the code, there is a ton going on in there!!

Sound Effects

I went ahead and used the XACT utility to import some .wav files. I created a new wavebank, and a new soundbank. The two sounds I used were the mouseover and mousedown sounds. When I saved off the project, it created a xap file (I assume that is their project file extension). When I compiled, it created three files, a .xgs , a xsb, and a xwb. I am thinking xgs stands for XACT Global Settings , which I found is also referenced in my torquesettings.xml as a value for AudioGlobalSettings. I am also thinking that the xsb is XACT Sound Bank , and xwb is XACT wave bank.

Once I figured out how it was working, getting it to play wasnt too hard at all. I just had to set up the soundbank and wavebank in code, then tell the soundbank to play a cue. I tested it out, and it worked out great. I can now use sound effects (and I assume ambient music and soundtracks) throughout Arillian!!

World Generation

This is something I have been meaning to do some research heavily into. I thought I was set on a 2.5d world, but I am not so sure anymore. All the benefits of a 3d world just seem hard to pass up. I have heard it is more difficult, but thats ok, I am up for a challenge. I took a look at the new TorqueX 3d beta, and checked out some of the terrain loading code.

I am completely new to this whole process, so I noted the types they supported. Then I went and read what the heck a heightmap is, and found it to be fairly straightforward. I checked out terrain editors, and came across L3dt, FreeWorld3D, Terragen, and a host of others. This has me wondering if I can generate small 3d terrain heightmaps (in 16 bit .raw format) , and swap them in and out with the sceneloader, based on the Level State Machine.

I am thinking instead of one whole world, I only bring "chunks of it". I checked out the fps demo, and they have various .txscene files, and the definition of the terrain was in there. I am leaning towards L3DT (non Torque) one atm, but am still researching it.

Thats it for now. I am having fun researching and learning all these new aspects. Until the next update!

TorqueX Newbie Diary #1

David Everhart — 2007-11-27T00:51:40+00:00

Well, my foray into the world of Torque X has begun. I recently went through and paired down my scope to test out the viablity of using Torque X. Arillian (formerly World of Arillian) has around 20 races, 40 skill trees with each skill tree having around 10-15 skills (around 450 skills ), and a playable area roughly 5 times larger than Diablo II. For my feasibility test , I plan on the following:

Phase 1:
- Implement 1 Race (Human) with animations
- Implement 1 Enemy (skeleton) with animations
- Implement 2 Skills (1 active and 1 Passive)
- Implement 2 Areas (1 part of a town and a graveyard)
- Implement and Test Physics for player and enemy
- Implement and Test Basic AI for Enemy
- Implement Canvas State Machine [*Completed*]
- Implement Intro Splash Screen, Main Menu, Main Game GUI
- Implement Level State Machine
- Integrate 1 sound track, and several sounds for actions
- Test Basic combat

Phase 2:
- Implement Basic Inventory System
- Implement 1 NPC merchant and merchant framework
- Implement Basic quest framework
- Impement character selection GUI, character creation GUI, cutscene GUI

Now, I realize that looks ambitious, but given the scope of Arillian, this is a tiny slice to see if it is even viable. I want to make sure that all the above peices work before I progress any further. The goal is to get to the point where I can focus on content implementation. I want to ensure the framework I build makes it easy to do that, and although I could buy an addon or the like, I find its better to learn from the ground up (to some extent, Torque X looks like they already did the legwork on wrapping XNA) so I REALLY understand whats going on and what this baby can do! I have only had TorqueX for about two and a half weeks so far, and it has really impressed me. I went ahead and bought the source, because its easier for me to understand the intent of the Torque Engine components when I can see what it is wrapping in XNA, and how I can utilize it.

I have decided that Arillian will be done as a 2.5D game. I know it is possible now thanks to the help of this community. I am going for the 2d isometric look (for the environment), with 3d art assets (characters,items,effects, etc). I get the utility of using 3d for character runtime itemization while retaining an awesome 2d look and feel. More than likely, I will outsource my 3d modeling aspects as well as my soundtracks, and focus more on the game programming.

Since Torque X doesnt fully support 3d yet (in particular T2dShape3D), I decided to work on the GUI. My first test was to put some text on the screen, with the Exocet font (same font as diablo). I ran into a lot of issues with it, but finally found a XNAExtras pack that allowed me to convert the font I wanted into the format the TorqueX framework requires.

With that out of the way, I built a basic framework, using TorqueCombatPro as my tutorial project to look at. I used StarterGamePro as my basic template, and began adding in peices from torquecombat pro. I dissected each peice I moved over to fully understand how it works, why it works that way, and how I can extend it if need be. Having the source, and being able to trace it through the framework has helped me a lot on what is happening.

At this point, I have a functioning Canvas State Machine, that allows me to switch what is rendered on the GUICanvas by just simply setting the NextCanvasState variable from anywhere in the game. The Canvas state is checked for changes on each tick of an overidden update in my main game program. I have a basic splash screen which renders, then switches to a main menu page (nothing on it atm). I realize I will need roughly around 8-10 GUIs, but the framework to put them and manage the state of the GUICanvas has been implemented.

The next peice I am working on is the Level State Machine, which from skimming over it, looks to be a lot more complex. I will also be flushing out the intro splash screen, main menu GUI and basic main game gui. So much to do, but man is this fun!! Till the next update!

And so it begins...

David Everhart — 2007-11-24T01:27:27+00:00

When I was a kid , in the 6th grade, I was introduced to the commodore 64. My dad subscribed to a magazine called compute gazette, and I would spend hours typing in the code, and try to play. I learned to hate the term "Syntax Error "! This began a lifelong fascination with gaming for me.

Fast forward to my early twenties and a game came out that completely floored me. It was Blizzards Diablo. I was blown away by the dark theme, the action style of the game, the music, the graphics, and its rpg elements. Then its sequel came out later on called Diablo II , and then its expansion Lord of Destruction came out after that. I played the heck out of the whole series, and it left a big impression on me. I was in particular a huge fan of the necromancer class. I havent really seen a necromancer type class I liked since Diablo II. Every rpg I played after that was compared to those games. Most just didnt compare.

When hellgate london by Flagship Studios (The creators of the original Diablo) came out, I was pretty excited, thinking it might be the next Diablo II. I was dissapointed though, it shared some similarities, but not too much. I tried out the summoning class, and it was not quite what I expected. Their other offering was Mythos, and although I did not play it, the description of a light themed world, with a class based design didnt interest me much.

I began thinking about a gameworld I had been thinking of since my college days. I had various peices of information scattered around, and wondered to myself "How hard is it to create an isometric game like Diablo II , with a freeform skill based system?" Having been a developer for pretty much all my life, I naturally researched it, and came upon Managed Direct X.

My forays into that world were pretty daunting. Although I can read C# like a book, understanding all the aspects of Direct X, how everything tied in, and knowing what I write now, may change to the point that it requires a rewrite, made me look elsewhere. I came upon two engines, Torque X and Visual 3D.Net. Being new to the world of game development, I did some research, and have not yet fully decided as of yet, but I am leaning towards Torque X atm.

I realize I have a lot to learn, and am looking forward to creating my game "World Of Arillian" , an isometric viewable game ala Diablo II style with a 100% freeform skill based system (no classes here!). I have designed much of my gameworld on paper (and in MS Word!), and am still working on the combat mechanics and the like. Nonetheless, I have begun a new foray into the world of Torque X, and realize my ambitions will require a 3d engine. I am hoping they release torquex 3D soon, as I really like the 2d game builder. More to come as I get deeper into my game, but for now, since torque X does not support 3D, I am working on the GUI, which I hope will be transferrable! Until then...