Jump to content

  • Log In with Google      Sign In   
  • Create Account

Spa8nky

Member Since 19 Apr 2009
Offline Last Active Sep 06 2012 04:33 AM

#4894142 Looking for terminology and ideas for the following vector style.

Posted by Spa8nky on 15 December 2011 - 05:22 AM

Note how the bloom in the second screenshot is completely faked and baked into sprites, not created in the framebuffer:




That's a good eye you have there, thank you.


I'm still at a loss as to the best way to draw the original sprites before bloom processing, etc. My guess would be that simple shapes of 3-4 pixels in thickness would do it? The post processing should then eliminate aliasing and make the pixels more vector beam like?


#4893964 Looking for terminology and ideas for the following vector style.

Posted by Spa8nky on 14 December 2011 - 02:53 PM

I'm looking to produce graphics similar to that of the following:

Posted Image

What terminology should I be looking for to find references on this particular style?

My initial thought of "retro vector art" doesn't return this particular style on Google.

I can see that the Bloom technique has been used. Has High Dynamic Rendering been used also?

I can see that the screen has been given a fishbowl effect, along with thick scanlines; I am not interested in that as much as the graphics themselves.

This screenshot also shows what I would like to achieve (without the effects)

Posted Image

Any thoughts on where to begin for drawing the basic "sprites?" would also be welcome. Would I be best using a vector art program or sticking with pixels?


#4857094 [C#] Have all settings derive from one base class?

Posted by Spa8nky on 03 September 2011 - 04:14 AM

I've been thinking about making all my scene objects easier to serialize and deserialize.

Currently when an object is added to the scene, I determine what type it derives from and put it into different lists accordingly:


        public void Add(object o)
        {
            BaseLight light = o as BaseLight;

            if (light != null)
            {
                deferredRendering.AddLight(light);
            }

            IOctreeObject octreeObject = o as IOctreeObject
            if (octreeObject != null)
            {
            	octree.Add(octreeObject);
            }

            ITriggerable triggerable = o as ITriggerable;

            if (triggerable != null)
            {
                triggerables.Add(triggerable.TriggerID, triggerable);

                form.IsEventIgnored = true;

                Control[] c = form.Controls.Find("listViewTriggersAllObjects", true);

                ListView l = c[0] as ListView;
                l.Items.Add(triggerable.TriggerID.ToString(), string.Format("[{0}] ID: {1}", o.GetType().Name, triggerable.TriggerID), 0);
                l.Items[l.Items.Count - 1].Tag = triggerable.TriggerID;

                form.IsEventIgnored = false;
            }

            TriggerVolume triggerVolume = o as TriggerVolume;

            if (triggerVolume != null)
            {
                triggerVolumes.Add(triggerVolume);
            }

            VoxelEntityMarker voxelEntityMarker = o as VoxelEntityMarker;

            if (voxelEntityMarker != null)
            {
                voxelEntityMarkers.Add(voxelEntityMarker);
            }

            WidgetControllable widgetObject = o as WidgetControllable;

            if (widgetObject != null)
            {
                widgetObjects.Add(widgetObject);
            }
        }

This is great for dealing with individual class types in groups but it is lousy for serializing settings as I can't just iterate through each group as some objects might belong to more than one group.

To get around this I thought that I would have all my scene objects derive from an interface that made sure each scene object was added to a main list as well as the individual lists above.

All the scene object settings classes could derive from a single SceneObjectSettings class also:


    public class SceneObjectSettings
    {
        public EntityType Type;
    }


    public enum EntityType : byte
    {
        Door,
        Health,
        Light,
        Zombie
    }

This would make writing the settings as easy as:


        public SceneObjectSettings[] Write()
        {
            int numSceneObjects = sceneObjects.Length;

            for (int i = 0; i < numSceneObjects; ++i)
            {
                sceneObjects.Write();
            }
        }

and reading the settings would be a case of:


        public void Read(SceneObjectSettings[] settings)
        {
            int numSettings = settings.Length;

            for (int i = 0; i < numSettings; ++i)
            {
                switch (settings[i].Type)
                {
                    case EntityType.Door:
                        {
                            Door door = new Door(this, settings as DoorSettings);
                            break;
                        }
                    case EntityType.Health:
                        {
                            Health health = new Health(this, settings as HealthSettings);
                            break;
                        }
                    case EntityType.Light:
                        {
                            Light light = new Light(this, settings as LightSettings);
                            break;
                        }
                }
            }
        }

I would like to know what you guys thought about this approach to the problem I'm having?


PARTNERS