Dmitry Timofeev

"GB&W Lite" [wp7][game][release]

2011-10-15T16:04:00.003+04:00

Выпустил лайт версию игры GB&W.

Вот видео с мастер классом по прохождению 19го уровня:

игру можно найти тут:

http://windowsphone.com/s?appid=127a61e4-a6a9-4c0a-b4e4-b1469856d22b

Как видите есть ряд изменений в оформлении, они коснулись и полной версии приложения для которого вышло соответствующее обновление.

Оказалось, при первой публикации лайт версии,GB&W занимает в памяти более 90 МБ (на сколько не скажу). Очень много анимированной растровой рафики. Лайт версию пришлось немного порезать. Получается для GB&W мне в свое время сделали скидку :).

Компромисс в выборе между классом и структурой

2011-07-13T21:33:00.007+04:00

На тему навела вот эта статья "NET 4.0: Class vs Struct или в чём различия между Классом и Структурой" . Давно уже собирался собрать для себя набор иерархии универсальных коллекций, которые не попадают под сборку мусора. Тема в очередной раз стала интересна после моего известного эксперимента с Windows Phone 7. Очень сомневаюсь, что моя статья будет полезна для бизнес-приложений. Меня больше интересует данная тема для использования в XNA/DirectX и как область применения - игры.

Приглашаю вас обсудить данный вопрос.

И так, условия задачи:
- Нужна коллекция элементов для описания, например, системы частиц (это может быть все что угодно). Такая штука в которой в среднем 60 раз в секунду добавляются и удаляются сотни элементов.
- Изменения в коллекции не должны влиять на сборку мусора.
- Нельзя использовать структуры! Только ссылочные типы.
- Запрещено создавать и удалять классы, за исключением первой инициализации.
- Физическое количество элементов в коллекции должно быть постоянным. Т.к. изменение длинны массива достаточно накладная операция, а количество элементов должно постоянно плавать, то подойдет подобие кеша. Ограничение - разработчику желательно четко знать максимально возможное количество элементов в такой коллекции. А это значит игра должна быть грамотно спроектирована. Хотя лазейку я оставлю.

Набросал вот такой черновик.

Базовый класс для элемента коллекции:

public class TElementConstLength
    {
        private  int indexInCollection = -1;
        internal int IndexInCollection { get { return indexInCollection; } }
        internal void SetIndexInCollection(int i)
        {
            indexInCollection = i;
        }
    }

Базовый класс для коллекции:

public class TCollectionConstLength<T> where T : TElementConstLength, new()
    {
        private T[] elements;

        private int count = 0;
        /// <summary>
        /// Количество живых элементов
        /// </summary>
        public  int Count { get { return count; } }

        private int end = -1;

        /// <summary>
        /// Инициализация колекции
        /// </summary>
        /// <param name="length">Длинна коллекции</param>
        public TCollectionConstLength(int length)
        {
            elements = new T[length];
        }

        /// <summary>
        /// Доступ к элементу по индексу
        /// </summary>
        /// <param name="index">Индекс</param>
        /// <returns>Элемент</returns>
        public T this[int index]
        {
            get { return elements[index]; }
        }

        /// <summary>
        /// Выделение места под новый элемент
        /// </summary>
        /// <returns>Новый элемент</returns>
        public virtual T GetNew() // = Add
        {
            // если список полон, для режима отладки
            if(end == elements.Length - 1)
                Array.Resize(ref elements, elements.Length + 1);
            // 
            end++;
            count++;
            // если не инициализирован элемент
            if(elements[end] == null)
            {
                elements[end] = new T();
                elements[end].SetIndexInCollection(end);
            }
            //
            return elements[end];
        }

        /// <summary>
        /// Очистка списка
        /// </summary>
        public void Clear()
        {
            end = -1;
            count = 0;
        }

        /// <summary>
        /// Удаление элемента по индексу
        /// </summary>
        /// <param name="index">Индекс</param>
        public virtual void Remove(int index)
        {
            // выход за пределы
            if(index < 0 || index > end)
                return;
            if(index < end)
            {
                // рокировка элементов
                T temp = elements[end];
                elements[end] = elements[index];
                elements[index] = temp;
                // рокировка индексов
                int i = elements[end].IndexInCollection;
                elements[end].SetIndexInCollection(elements[index].IndexInCollection);
                elements[index].SetIndexInCollection(i);
            }
            // уменьшаем список
            end--;
            count--;
        }

        /// <summary>
        /// Удаление элемента
        /// </summary>
        /// <param name="e">Элемент</param>
        public virtual void Remove(T e)
        {
            // проверка на соответствие ссылок (защита от тупости)
            if(e != elements[e.IndexInCollection])
                return;
            Remove(e.IndexInCollection);
        }
    }

Вот пример для тестов:

using System;

namespace CollectionConstLength
{

    public class ElementTest : TElementConstLength
    {
        private string name;
        public string Name { get { return name; } set { name = value; } }
        public ElementTest() { }
    }

    class Program
    {

        static TCollectionConstLength<ElementTest> item;

        static void Main(string[] args)
        {

            item = new TCollectionConstLength<ElementTest>(5);
            ElementTest et;
            for(int i = 0; i < 5; i++)
            {
                et = item.GetNew();
                et.Name = i.ToString();
            }
            //
            Print();
            //
            item.Remove(item[1]);
            Print();
            //
            Console.ReadKey();
        }

        static void Print()
        {
            Console.WriteLine("//--------------------------------");
            for(int i = 0; i < item.Count; i++)
            {
                Console.WriteLine(
                    string.Format("index - {0}; name - \"{1}\";", 
                        item[i].IndexInCollection, 
                        item[i].Name));
            }
            Console.WriteLine("//--------------------------------");
        }
    }
}

Пример наращивания функционала через наследование:

- Расширенный класс элемента:

public class TUpdate : TElementConstLength
    {
        public virtual void Update() { }
    }

- Расширенный класс коллекции

public class TUpdateCollection<T> : TCollectionConstLength<T> where T : TUpdate, new()
    {
        public TUpdateCollection(int l) : base(l) { }
        public virtual void Update()
        {
            for(int i = 0; i < base.Count; i++)
            {
                base[i].Update();
            }
        }
    }

Данный подход позволяет исключить сборку мусора и равномерно распределить нагрузку на процессор. Для каждого наследника от базового класса нужно добавить метод заполняющий поля данного класса, что делает процесс инициализации нового члена коллекции похожим на инициализацию структуры.

Давайте пообщаемся на эту тему.
Так же буду рад ссылкам на статьи с подобными темами и изысканиями.

От идеи до реализации: история игры GB&W

2011-07-06T19:31:00.002+04:00

Написал о создании игры статью для wp7rocks.com

"От идеи до реализации: история игры GB&W"

Лето ... Юмор ...

2011-07-02T20:51:00.002+04:00

Бред конечно, но когда пытаешься сосредоточиться на работе, а тебе при этом постоянно мешают, еще эта жара - именно такие мысли лезут в голову:

Тенгизи: к сожалению, пока некогда :(( работа... осенью закуплю девайсы и морозными зимними вечерами... :)

Dmitry: да.. да..)))

Dmitry: я вот тут думаю, как бы до морозных вечеров обороты набрать, что бы потом только щепки летели)))

Тенгизи: лето... мозги вообще ничего делать не хотят... :((

Тенгизи: у нас жара вторую неделю... жесть...

Dmitry: ищу стимулы, у нас тоже пекло)

Тенгизи: ну у вас-то еще бы!

Dmitry: )))

Тенгизи: мы-то люди северные, к жаре не привычные

Dmitry: да я лето из за лени ненавижу)))

Тенгизи: хотя я 17 лет в минводах прожил, но тут уже адаптировался... )

Dmitry: у меня такое подозрение, что для того что бы я смог раскрыть все свои способности, по максимуму, и реализовать их - меня нужно запереть на какой ни будь полярной станции и не выпускать.

Dmitry: только с компом и интернетом)))

Dmitry: и раз в неделю привозить еду и женщин)))))))))))

Dmitry: ух ...

Тенгизи: у меня такое же мнение!!! сто пудово! если запереть - реализуемся...

Тенгизи: даже женщин на хрен не возите, только отвлекать будут... потерплю тройку месяцев ))))

Dmitry: раз в неделю можно часок расслабиться)))

Тенгизи: при таком раскладе даже в покер научится играть можно профессионально... ))

Тенгизи: ну.. если часок... но потом чтоб СРАЗУ УВОЗИЛИ! :))

Dmitry: прилетела на вертолете, еды привезла, удовлетворила и улетела)))

Dmitry: идеал женщины)))

Тенгизи: )))))))

Тенгизи: к тому же чтоб глухонемая была ))

Dmitry: не вопрос)))

Приятно осознавать, что ты не один такой :)

"GB&W" in "Top WP7 Games : June 2011 [ POLL ]"

2011-07-02T13:36:00.001+04:00

Сайт bestwp7games.com предложил голосование за игры для Windows Phone 7 вышедшие в июне. В этом списке на ряду с топовыми играми, имеющими статут xbox live, каким то образом, оказалась и наша игра GB&W. Приглашаю вас присоединиться к нашей группе болельщиков и принять участие в голосовании.

Проголосовать можно тут

Регистрация не нужна. Достаточно выбрать соответствующий пункт и подтвердить кнопкой "vote".

Всем огромное спасибо за отклик и участие!

P.S. Топовым играм, имеющим статус xbox live и команду поддержки, хватает внимания, загрузок и покупок, а вот нам бы все это даже очень не помешало.

GB&W - Update v1.4

2011-06-13T23:22:00.001+04:00

Это уже 4-е обновление.

Сейчас доступно:
- 40 уровней.
- 14 типов кирпичей
- 14 бонусов

Одна из последних добавленный пакостей это кирпич с кодовым названием "Биомасса". Он не прерывно плодиться с постоянной скоростью, кроме того он подвержен влиянию 2х бонусов:
- катализатор, единовременно ускоряющий рост общего объема биомассы
- заморозка, соответственно временно останавливающий рост биомассы.

Вот новое видео:

GB&W и Конкурс мобильных приложений

2011-05-18T22:48:00.002+04:00

С начала главный вопрос на повестке дня).

Сегодня зарегистрировал свой проект в конкурсе мобильных приложений под Windows Phone 7 на сайте конференции DevCon•11. В конкурсе участвует следующее видео:

Ребят у меня к вам просьба - кому симпатичен данный проект, пожалуйста не пожалейте 5 секунд своего времени, проголосуйте за него, для меня важен каждый Ваш голос. Ниже кнопочка для голосования:

Заранее благодарен.

Наконец то завершена работа над первым релизом игры. Почему первым? Потому что в планах добавлять уровни в следующих обновлениях. Сейчас приложение находится на этапе публикации в Marketplace.

GB&W - Windows Phone 7 game preview 3

2011-04-23T15:05:00.011+04:00

Не пугайтесь обилию выпадающих бонусов. Это один из первых десяти обучающих уровней. Десятка разбита по применению тематических бонусов их комбинаций.
В этом уровне первый раз появляется усиление на пулемет, который в свою очередь превращается в нечто иное :).

Рекомендую смотреть в качестве 720p (сейчас 480p)

Мне часто задают вопрос - как происходит управление в игре и как целиться? Все просто. Кораблик управляется одним касанием и постоянно находится под пальцем. Пулеметы наводятся на ближайшую цель в радиусе поражения. Вторым касанием на кнопки в верхней панели активируется тяжелое вооружение:
ракета I - открыть/закрыть подвеску, для экономии боезапаса. Само наводится и поражает ближайшего бота. При потере цели в процессе подлета (цель уничтожена др. ракетой и т.д.) находит и атакует следующую ближайшую.
ракета II - пуск. Само наводится и поражает/запечатывает ближайшую шахту из которой появляются боты.
ракета III - активация ракеты. Второе нажатие в области экрана помечает область поражения и происходит старт. Так же взрывается от столкновения с кирпичами.

Я потратил какое то время на изменение своего Touch класса. Теперь он понимает второе касание типа Tap при активном первом касании. Т.е. можно не прерываясь контролить кораблик и активировать ракетные бонусы.

"Guns, Balls & Walls" - Windows Phone 7 game preview 2

2011-03-23T23:57:00.000+03:00

Делюсь очередным видео. Музыкальное сопровождение отключено по политическим соображениям. Еще нет четкой договоренности с композитором.

"Guns, Balls & Walls" - Windows Phone 7 game preview

2011-03-07T16:22:00.004+03:00

Игра предназначается для Windows Phone 7 marketplace.
Cуть игры - смешанный коктейль трех направлений:
1) арканоид - основная идея и условия прохождения уровня.
2) аэрохоккей - расширенные правила взаимодействия биты(battleship) и мяча
3) хардкорный 2d шутер - пулеметы, ракеты, враги, кровь, взрывы ... боже дай мне сил остановиться :))).

Отладочный уровень:

Планируется сменное оружие для обоих типов вооружения,
а так же их прокачка. Возможные параметры: дальность, урон, скорострельность. Пока остановимся на стандартных амбициях.

В целом данный проект является экспериментом, в том числе и в 2d.
Очень много времени уходит на рисование, особенно что касается на первый взгляд не заметных деталей таких как кровь на решетках вентиляторов и т.д. . Примерное соотношение времени = (день рисую) / (час программирую). С самим вопросом рисования проблем нет, но не набита рука, плюс, например, если в карандаше я нарисую все что угодно, то ощущение цвета нужно еще нарабатывать. Радует то, что по мере работы прокачка движется. Мега респект создателям графического редактора Paint.net

Windows Phone 7 радует своими возможностями. По предварительным подсчетам, в данном приложении, запас на частицы порядка 4000 штук. Возможно при желании у меня получится и больше. Время покажет.

XNA GUI library for Windows & Windows Phone 7. General Presentation Foundation

2011-02-10T01:32:00.007+03:00

Вот на таком эпическом названии остановился мой выбор). В основном такая идея была продиктована большой схожестью названий и возможностей элементов библиотеки с технологией Windows Presentation Foundation. Это как бы должно с первых шагов подвести пользователя к мысли что все просто и знакомо в обращении. В библиотеке есть еще места которые можно в перспективе рефакторить для еще большей схожести, но всему свое время. У меня ушло очень много времени на создание сайта на сильверлайте. Именно сильверлайт я выбрал по причине отсутствия необходимости учить для меня что то новое, т.к. я ни когда не работал в области web и это мой первый сайт.

Пересекая очередной финиш, хочу выразить огромную благодарность за помощь, советы и творческие обсуждения своим друзьям:
- Сергей Лутай - блог - твиттер
- Сергей Звездин - блог
- Ильшат Хабибуллин
Спасибо ребят).

Сам сайт продукта http://generalpf.ru

Comments for Vic Gundotra message:"#feb11 Two turkeys do not make an Eagle"

2011-02-10T00:32:00.000+03:00

Забавный мужик этот Vic Gundotra. Он является вице-президентом по разработкам в Google. В своем блоге он оставил такое сообщение "#feb11 Two turkeys do not make an Eagle", что по нашему звучит как "11 февраля Из двух индеек не получится Орла". Мало кто сомневается, что речь идет о возможном альянсе Microsoft и Nokia.

Заерзали значит, это хорошо). На уровне вице-президента публичные цирки происходят.

"Кроме мяса, индейки дают много ценного пуха и пера" [Домашняя индейка], а орел?))).

У одной индейки богатый опыт в области мобильных решений, правда ОС не сахар, видимо софт не их занятие. У другой большой потенциал с софтом и возможностями. Есть повод для переживаний).

XNA, GarbageCollector, SynchronizeWithVerticalRetrace, IsFixedTimeStep – используйте правила и будет вам счастье …

2011-01-14T18:16:00.001+03:00

И так по порядку. Что значат эти термины:

SynchronizeWithVerticalRetrace – public properties GraphicsDeviceManager. Gets or sets a value that indicates whether to sync to the vertical trace (vsync) when presenting the back buffer (MSDN). Эта штука синхронизирует переключение back buffers с частотой обновления экрана монитора. Зная, как технически происходит обновление изображения на мониторе, можно сказать, что включение данного параметра нужно для предотвращения разрезания изображения при смене кадров.

IsFixedTimeStep - public properties Microsoft.Xna.Framework.Game. Gets or sets a value indicating whether to use fixed time steps (MSDN). Параметр, отвечающий за включение или отключение режима, который отвечает за ограничение частоты вызовов метода Update.

GarbageCollector – системный сборщик мусора. Конкретно нас будет интересовать класс System.GC .

Как работают SynchronizeWithVerticalRetrace и IsFixedTimeStep. Есть четыре сочетания данных флагов:
1. SynchronizeWithVerticalRetrace = false и IsFixedTimeStep = false
В этом случае графические буферы меняются по мере их рисования, не дожидаясь синхроимпульса, синхронно вызывается метод Update.
Особенности: обычно в приложении не требуется вызывать метод Update с максимально возможной частотой. При SynchronizeWithVerticalRetrace = false мы имеем возможность измерять значение fps превышающее частоту обновления монитора. Активно пользуюсь при отладке приложения.
2. SynchronizeWithVerticalRetrace = false и IsFixedTimeStep = true
В этом случае мы можем дополнительно контролировать частоту вызова методов Update и Draw и устанавливать фиксированный интервал через свойство TargetElapsedTime.
Особенности: сомнительное удовольствие применять данный подход повсеместно. Он подходит, для каких либо исключительных случаев, в которых его применение полностью обоснованно. Не пользуюсь.
3. SynchronizeWithVerticalRetrace = true и IsFixedTimeStep = false
Тут все просто, обновляем, рендерим, ждем синхронизации, меняем back buffers и по новой.
Особенности: невозможно измерить значение fps выше частоты обновления монитора. Пользуюсь.
4. SynchronizeWithVerticalRetrace = true и IsFixedTimeStep = true
Интересный случай. Если время синхронизации меньше IsFixedTimeStep, то ждем следующей синхронизации и только после этого выполняется Update и Draw. Если же время синхронизации больше IsFixedTimeStep, то по факту выполнения синхронизации не медленно выполняется Update и Draw. Эдакий хромающий ослик без одной ноги).
Особенности: теряюсь в догадках где это можно применить, точно не мой профиль). В некоторых случаях при значениях TargetElapsedTime/ vsyncTime = 1.5f (примерно) можно на глаз заметить не равномерное обновления экрана. Не пользуюсь.

Уже теплее. И так, о главном). Если вы написали приложение|игру используя XNA, применили из вышеописанных приемов 1й или 3й и в вашем приложении наблюдаются периодические задержки, а вы к тому же нечайно вспомнили «слова которые нельзя произносить» - Garbage Collector ))). Главное не паникуйте, при этом не обязательно писать в различных форумах Ваше мнение о .net и XNA, крутости и преимуществах C++. Все это от нервов, нервы от не знания, не знание от лени, лень от глупости, но это лечится.

Как пользуется Garbage Collector’ом рядовой «пользователь» Visual Studio? Да ни как. Он полагается на настройки по умолчанию для Garbage Collector’а. Настройки по умолчанию рассчитаны на так называемые бизнес приложения, для динамичной работы с DirectX нужно доработать.

По умолчанию Garbage Collector выполняет освобождение памяти в любом случае не синхронно с работой Update. Мертвый груз копится и освобождается в непредсказуемый, для логики вашего приложения, момент. Самый простой выход – это делать в начале очередного Update:
System.GC.Collect(1);
Где 1 это номер поколения, значение подобрано экспериментально.

С другой стороны может быть не целесообразно перегибать палку и выполнять сборку мусора 60 раз в секунду при включенной синхронизации (если у монитора такая рабочая частота обновления экрана) или более 60 раз при выключенной синхронизации.
По этому можно сделать так:

using System;
using System.ComponentModel;
using Microsoft.Xna.Framework;

namespace GeneralPresentationFoundation.gSystem.gGarbageCollector
{
    public class GarbageCollector
    {

        private BackgroundWorker bw = new BackgroundWorker();

        private int stepNumber = 0;

        private int sleepStep = 1;
        public  int SleepStep { get { return sleepStep; } set { sleepStep = value; } }

        public GarbageCollector()
        {
            Init();
        }

        public GarbageCollector(int sleepStep)
        {
            this.sleepStep = sleepStep;
            Init();
        }

        private void Init()
        {
            bw.DoWork += new DoWorkEventHandler(bw_DoWork);
        }

        public void Update()
        {
            if(!bw.IsBusy)
            {
                stepNumber++;
                if(stepNumber == sleepStep)
                {
                    stepNumber = 0;
                    bw.RunWorkerAsync();
                }
            }
        }

        private void bw_DoWork(Object sender, EventArgs e)
        {
            GC.Collect(1);
        }
    }
}

Возможно не везде будет полезным применение потока, это просто мой случай.
GarbageCollector gc = new GarbageCollector(20);
т.е. при частоте монитора 60 Гц - 3 раза в секунду.

RSDN совместно с MSDN сообщают о новом конкурсе статей по технологиям Microsoft

2010-12-01T14:50:00.002+03:00

RSDN совместно с MSDN сообщают о новом конкурсе статей по технологиям Microsoft, посвященных одной из двух тем:
- Возможности операционной системы Windows 7
- .NET
На конкурс принимаются русскоязычные технические статьи, присланные на адрес submit@rsdn.ru в период с 12 октября по 31 января 2011 года.
Первые три места получают:
1 Notebok Acer "Aspire 3820TG-5464G50iks"
2 Коммуникатор HTC "HD2 T8585"
3 XBox 360

Участники, написавшие интересные статьи, но не попавшие в первую тройку, получат специальные призы от жюри:
4 Microsoft "Wireless Laser Desktop 7000"
5 Microsoft "Natural Ergonomic Keyboard 4000"
6 Microsoft "Wireless Arc Mouse" ZJA-00010

Подробности тут

GPF - "WPF" for XNA

2010-10-14T18:36:00.000+04:00

GPF - на таком рабочем названии библиотеки я остановился.

Сегодня закончил модуль 3d форм - это такой штука, обеспечивающая
функционал добавления в сцену объектов на плоские грани которых можно проецировать формы и оперировать ими указателем мыши.

Пока не стал возиться с наложением форм на не плоские поверхности по
причине того, что это нарушит совместимость с Windows Phone 7 экземпляром библиотеки.

Вот такое видео:

Показал Expander, DataGrid, Table.
Со стилями элементов опять не поиграл. Оставил на потом)

XNA. gEngine. Forms (GUI)

2010-10-09T21:30:00.005+04:00

Вот и созрел я до первого показа своего интерфейса для приложений реализованных на базе XNA. Как говорится лучше один раз увидеть …, так не буду Вас задерживать:

Рекомендую смотреть в HD режиме.

Данное видео не показывает всех элементов и возможностей. Опубликовал по многочисленным заявкам. За продолжением следите в следующих сериях.

Идея архитектуры, данного интерфейса, базируется на архитектуре предложенной в WPF. Но ядро и элементы написаны с нуля и оптимизированы под 3d. Так же данная библиотека работает и на Windows Phone 7.
Список уже реализованных элементов выглядит следующим образом:
- Button
- Canvas
- CheckBox
- CheckElement
- ConsoleOutput
- DataGrid
- Expander
- Image
- ListSelector
- Menu
- ProgressBar
- ScrollBar
- ScrollDiagram2d
- ScrollView
- Slider
- StackPanel
- Switch
- TabControl
- Table
- TextBlock
- TextBox
В этот список попали не характерные для WPF элементы, что было продиктовано первоочередной необходимостью реализации отображения функционала 3d движка.
В представленном видео все элементы и формы выводятся с простым базовым стилем. Под базовым стилем подразумевается (если есть) прямоугольная рамка и (если есть) прямоугольник фона. Стиль любого элемента достаточно просто меняется наследованием от него нового нового класса. Я пока не стал перегружать рабочую версию интерфейса надуманным стилем и растровой графикой, бесполезная трата времени на то что в последствии не пригодится.

Фрагмент истории xnadev.ru

2010-10-07T19:03:00.003+04:00

Своим рассказом хочу развеять некоторые предрассудки, заблуждения и прояснить ситуацию.

Как то зашел разговор о том, что с различных ресурсов, пользователей задающих вопросы по XNA, перенаправляют на наш сайт xnadev.ru. Пользователи приходят не (!) регистрируясь осматриваются, чаще всего делаю вывод о том что форум мертв и уходят. Т.е. не задерживаются.

На самом же деле форум не мертв. Собралась достаточно дружная компания, костяк из админов, MVP, активных грамотных пользователей, плюс немного интересных и эксцентричных персонажей, добавляющих в наше общение позитив, и прочие читатели. Каждый занимается своим делом, временами рассказываем, показываем наработки. Ежедневно отвечаем на вопросы (я это делаю по вечерам). Общаемся в меру свободного времени и настроения.

Но до недавнего времени доступ к самым активным веткам форума был закрыт (!) для не зарегистрированных пользователей. Без злого умысла, данное обстоятельство было продиктовано техническими ограничениями тарифа хостинга сайта (нагрузки, трафик и т.д.), а так как админы платили кровные из своего кармана, то пояса пришлось затянуть по туже. Сейчас мы сменили хостинг, переехали на 1gb.ru. Еще раз спасибо за содействие Евгению Марченкову (Microsoft). Возможности расширились и мы изменили права доступа для всех пользователей (и соответственно поисковых систем). Вот такая вот наша сказка).

Милости просим.

Твоя Microsoft Visual Studio 2010 Ultimate with MSDN Subscription

2010-09-20T23:55:00.001+04:00

Внимание акция в рамках ресурса

xnadev.ru

напиши статью и получи:

Microsoft Visual Studio 2010 Ultimate with MSDN Subscription

Такой подарок получат первые двое авторов статей на темы из области XNA. Двое т.к. активационных кодов у меня осталось два.

Поспешите, срок активации ограничен!

Windows Phone 7 + XNA 4.0 + Test Game

2010-05-19T19:13:00.002+04:00

Поигрался с Windows Phone 7, начал с проверки возможностей 2D, вот что получилось:

очень пока не хватает возможности использовать собственные шейдеры, а решать этот вопрос в обход длинным путем не очень хочется. так бы уже можно было поиграть с normal maping и добавить к рельефу освещение).

Твой путь

2010-02-27T23:15:00.014+03:00

Данную статью я посвящаю трем категориям людей: евангелистам Microsoft, работодателям и специалистам, связавшим свою деятельность с платформой dotNet (далее будем подразумевать язык C#). На написание данного опуса меня вдохновило очередное перечитывание книги «CLR via C#» Джеффри Рихтера. Сейчас объясню почему.

На данном историческом этапе людям, позиционирующим себя как dotNet разработчики, зачастую приходится отвечать на вопросы подобные этим:

- почему вы выбрали C#, а не C++?
- чем C# лучше C++?
- а вы знаете, что C# медленнее C++? (очередной «капитан очевидность»)

Работодателей выделю в отдельный абзац, по причине существования тенденции непонимания ими основополагающих факторов. В моей практике не так давно был веселый случай, когда перспективный работодатель, зная мое владение C++, предложил работу, которая подразумевала бы мой абсолютный переход обратно на C++. На что, получив мой отрицательный ответ, мотивированный нежеланием делать шаг назад, начал дискуссию в лучших традициях “Holy wars C++ vs C#”. Но война не сложилась. Видимо сказалось мое накопленное к тому моменту недовольство с оплатой предыдущих проектов, в итоге гражданин дуется на меня до сих пор, так и не поняв мотивов и побуждений движущих мною. По этому, уважаемые работодатели, на подобные предложения я хотел бы ответить Вам цитированием слов абсолютного авторитета в нашей области Джеффри Рихтера (цитата приведена далее по тексту и выделена курсивом, особенно ценное выражение выделено жирным курсивом). И если в ответе на ваше предложение вы нашли ссылку на данную статью, то мой ответ скорее отрицательный, чем положительный.

Так же постоянно находятся желающие, хотите вы этого или нет, поспорить с вами, развязать священную войну и доказать что именно C++ есть единственный и ничего кроме него. От серьезного человека Вы вряд ли такое услышите и скорее всего найдутся более интересные темы для беседы с ним. Разработчики с такими ситуациями сталкиваются в своей повседневной деятельности, в разговорах с коллегами, желающими выделится на вашем фоне, и т.д., евангелисты на встречах, семинарах, выступлениях, докладах. У каждого из нас есть свой багаж аргументов и оборонительных тактик, что является естественным. Не всегда выгодно игнорировать человека. Иногда обстоятельства складываются так, что остается только два пути пасовать или побеждать. Для победы, желательно не затягивая дебаты, нужны веские и достаточные аргументы. Какими же эти аргументы должны быть? Возьмем за основу три принципа:

1. Козьма Прутков: «Зри в корень» -> определи - что для оппонента является точкой опоры.
2. Основополагающее правило РРБ: «Лишить противника равновесия максимально эффективно и быстро» -> соответственно выбить почву из под ног, лишив опоры.
3. Геометрический метод: «Доказательство от обратного» -> все действия нужно провернуть с позитивом, не стандартно и оригинально.

Исходя из выше сказанного и того, что ваш оппонент ярко выраженный фанат С++, а так же человек не желающий развиваться дальше достигнутой ступеньки. Возьмем за основу нашей тактики следующую последовательность вопросов:

1. Какая книга и какого автора является для вас библией в вашей профессиональной деятельности как C++ программиста? – естественно автор будет Джеффри Рихтер или вы общаетесь не с программистом.
2. Что из себя представляет Джеффри Рихтер как специалист и кем он является: например по отношению к таким компаниям как Intel, DreamWorks и Microsoft? – нужно понимать, что данным вопросом мы преследуем сразу несколько целей. Во-первых: он подготавливает ситуацию к финальному ходу. Во-вторых: есть возможность заработать бонусные балы себе в глазах свидетелей (в зале например), если человек не владеет информацией глубже литературной деятельности автора. В-третьих: мы получаем добровольное признание оппонента в том, что данный автор является для него авторитетом с абсолютной степенью значимости. «… кто его тронет, он же памятник! …» - Рихтер выступал в роли консультанта для таких компаний как Intel, DreamWorks и Microsoft.
3. И контрольный вопрос: Как вы относитесь к высказыванию Джеффри Рихтера в одной из относительно недавних его книг? А конкретно:

«…Уже несколько лет я использую .NET Framework и должен сказать с уверенностью, что ни за что не вернусь к устаревшим технологиям абстрагирования и способам разработки ПО. И, если меня заставят, я предпочту сменить профессию! Вот как трудно отвыкать от хорошего. Честно говоря, вспоминая, чего стоило создавать приложения с использованием старых технологий, я просто не могу представить, как разработчикам вообще удавалось так долго создавать работающее ПО.»
Джеффри Рихтер, книга «CLR via C# программирование на платформе .NET FRAMEWORK на языке С#» 2-е издание, Введение, страница XIV.

За сим прощаюсь с вами. Вешаю на свой щит, как икону, фото и цитату Рихтера и со словами «изыйдите нечистые» продолжу свой путь.

P.S. Данная статья является результатом стечения обстоятельств и соответствующего настроения )

P.S.S. За статьей последовала переписка с Джеффри Рихтером, которую я привожу с его на то разрешения (Разговорный английский ни когда не был моей сильной стороной):

- Good day Jeffrey. I'm Russian developer and I adore Your books, that has directed me on writing the following article: «Твой путь». This article writing on Russian language. I be very happy if see You comment, if You have possibility.
- Добрый день Джеффри. Я являюсь русским разработчиком и достаточно сильно уважаю ваши книги, что вдохновило меня на написание следующей статьи: «Твой путь». Данная статья написана на русском языке. Я был бы очень счастлив увидеть Ваши комментарии, если Вас это не обременит.
-- Dmitry Timofeev

- I read your post via a translator which didn't do a great job of translating the text but I think I get the general gist idea of what you are trying to say. I have to say that C# is a much more programmer-friendly environment than C++ is. But, I also have to say that C++ can do some things that C# cannot do: more control over your system, better error recovery and, in some cases, better performance. I don't want to give the impression that C# is the solution for every problem. There are some problems that C++ is better suited for: operating systems and database servers come immediately to mind. Personally, I'm in a position where I would not go back to C++ development but there is still a needs for C++ developers as C# can't do everything.
- Я прочитал Ваш пост через переводчик, который не делал большой работы по переводу текста, но думаю, что понял то, что Вы пытаетесь сказать. Должен сказать, что C# является намного более благоприятной для программиста средой, чем C++. Но также должен сказать, что C++ может сделать некоторые вещи лучше, чем C# : возможен больший контроль над системой, лучшее восстановление после ошибок и, в некоторых случаях, лучшая производительность.
Я не хочу создать впечатление, что C# - решение для каждой проблемы. Есть некоторые задачи, для решения которых лучше подходит С++: на ум сразу приходят операционные системы и серверы баз данных. Лично я не хотел бы вернуться назад к разработке на C++, но есть все еще потребность в C++ разработчиках, поскольку C# не может сделать всего.
-- Jeffrey Richter (http://Wintellect.com)

- Thank's from comments. Your words once again emphasize true meaning my article. My opinion comply with You. I have attitude to programing in old school style. Including programming on periods: assembler Z80 (XZ Spectrum), c++, c++ and OpenGL, and in present time C#, particularly pay own attention XNA, it's explain my relation with quoting You words. I ask You permit publication in my blog from You mail comments.
- Спасибо за комментарий. Ваши слова еще раз подтверждают мысль моей статьи. Наши мнения совпадают. Я отношусь к программистам которых относят к старой школе (old school). Прохождение через периоды программирования на: ассемблере Z80 (ZX Spectrum), c++, c++ и OpenGL, и в настоящее время C #, особенно много уделяя собственное внимание XNA, может объяснить мое отношении к цитированию Ваших слов. Я прошу Вашего разрешения публикации Ваших комментариев в моем блоге.
-- Dmitry Timofeev

- Yes you may post what i sent you.
- Да Вы можете опубликовать то, что я послал Вам.
-- Jeffrey Richter (http://Wintellect.com)

#1 XnaDevRuEngine - 3d Max Export Plugin

2010-02-21T18:11:00.003+03:00

Заработал мой плагин экспорта из 3d Max. Были сложности с взаимодействием костей, но упорство, блокнот и карандаш все решили.

#0 XnaDevRuEngine

2010-02-04T22:34:00.005+03:00

Мои коллеги, с которыми меня объединяет деятельность в рамках ресурса xnadev.ru, и я, начали работу над 3D движком XnaDevRuEngine. Если не брать в расчет наработки по модулю интерфейса (forms), которые ранее существовали как самостоятельный проект, то следующее видео можно считать первым, демонстрирующим XnaDevRuEngine:

Сейчас частично готовы модули SceneTree и прототип ResorceManager.

Конкурс статей XNAdev.ru !!!

2009-09-18T22:26:00.003+04:00

С 1-го октября 2009 года, совместно с администрацией ресурса xnadev.ru, начинаем конкурс статей. Тематика статей XNA и 3D в целом.
Приз за первое место:
– годовая подписка MSDN Premium + Visual Studio Team System 2008 Team Suite

Подробности можно прочесть здесь ...

С#+XNA. В погоне за fps. I

2009-09-10T18:48:00.016+04:00

Краткое содержание:

- Введение;
- Часть 1-я. Новичкам;
- Часть 2-я. Та же песня с Microsoft'ом;
- Часть 3-я философская. Охотник или жертва;
- Заключение.

Введение.

Данная статья является попыткой посмотреть в корень проблемы. Проблемы достижения высоких показателей fps с точки зрения построения C# кода не касаясь при этом XNA раздела 3D, относящегося к непосредственным инструкциям видеокарте.

Часть 1-я. Новичкам.

Мои наблюдения основаны на постоянном присутствии в различных форумах и участии в различных проектах. Соль рассматриваемого мною вопроса заключается в использовании Fields и Properties членов классов и структур.
Для полноты ощущений, в моих изысканиях, меня интересовали следующие ссылочные типы:
- class;
- interface;
- object.
Сейчас мы просмотрим на время выполнения кода при различной организации доступа к членам класса.
Пример:


using System;
namespace TestObjectInterface
{
    class Program
    {
        static Unit[]       unit;
        static object[]     unitobj;
        static iUnit[]      uniti;

        static int          count;

        static void Main(string[] args)
        {
            count       = 10000000;
            unit        = new Unit[count];
            unitobj     = new object[count];
            uniti       = new iUnit[count];
            Init();
            double tf   = TestFields();
            double tp   = TestProperties();
            double tfo  = TestFieldsObject();
            double tpo  = TestPropertiesObject();
            double tpi  = TestPropertiesInterface();
            Console.WriteLine("testFields = "               
                + tf.ToString() + " mc, k = 1");
            Console.WriteLine("testProperties = "           
                + tp.ToString() + " mc, k = " 
                + (tp / tf).ToString());
            Console.WriteLine("testFieldsObject = "         
                + tfo.ToString() + " mc, k = " 
                + (tfo / tf).ToString());
            Console.WriteLine("testPropertiesObject = "     
                + tpo.ToString() + " mc, k = " 
                + (tpo / tf).ToString());
            Console.WriteLine("testPropertiesInterface = "  
                + tpi.ToString() + " mc, k = " 
                + (tpi / tf).ToString());
            //Console.ReadKey();
        }

        static void Init()
        {
            for (int i = 0; i < count; i++)
            {
                unit[i]     = new Unit(i, i * 2);
                uniti[i]    = (iUnit)unit[i];
                unitobj[i]  = (object)unit[i];
            }
        }

        static double TestFields()
        {
            DateTime dtStart = DateTime.Now;
            int n;
            for (int i = 0; i < count; i++)
            {
                n = unit[i].x + unit[i].y; // 0
                n = unit[i].x + unit[i].y; // 1
                n = unit[i].x + unit[i].y; // 2
                n = unit[i].x + unit[i].y; // 3
                n = unit[i].x + unit[i].y; // 4
                n = unit[i].x + unit[i].y; // 5
                n = unit[i].x + unit[i].y; // 6
                n = unit[i].x + unit[i].y; // 7
                n = unit[i].x + unit[i].y; // 8
                n = unit[i].x + unit[i].y; // 9
            }
            DateTime dtEnd = DateTime.Now;
            return (dtEnd - dtStart).TotalMilliseconds;
        }

        static double TestProperties()
        {
            DateTime dtStart = DateTime.Now;
            int n;
            for (int i = 0; i < count; i++)
            {
                n = unit[i].X + unit[i].Y;  // 0
                n = unit[i].X + unit[i].Y;  // 1
                n = unit[i].X + unit[i].Y;  // 2
                n = unit[i].X + unit[i].Y;  // 3
                n = unit[i].X + unit[i].Y;  // 4
                n = unit[i].X + unit[i].Y;  // 5
                n = unit[i].X + unit[i].Y;  // 6
                n = unit[i].X + unit[i].Y;  // 7
                n = unit[i].X + unit[i].Y;  // 8
                n = unit[i].X + unit[i].Y;  // 9
            }
            DateTime dtEnd = DateTime.Now;
            return (dtEnd - dtStart).TotalMilliseconds;
        }

        static double TestFieldsObject()
        {
            DateTime dtStart = DateTime.Now;
            int n;
            for (int i = 0; i < count; i++)
            {
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 0
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 1
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 2
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 3
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 4
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 5
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 6
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 7
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 8
                n = ((Unit)unitobj[i]).x + ((Unit)unitobj[i]).x; // 9
            }
            DateTime dtEnd = DateTime.Now;
            return (dtEnd - dtStart).TotalMilliseconds;
        }

        static double TestPropertiesObject()
        {
            DateTime dtStart = DateTime.Now;
            int n;
            for (int i = 0; i < count; i++)
            {
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 0
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 1
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 2
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 3
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 4
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 5
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 6
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 7
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 8
                n = ((Unit)unitobj[i]).X + ((Unit)unitobj[i]).Y; // 9
            }
            DateTime dtEnd = DateTime.Now;
            return (dtEnd - dtStart).TotalMilliseconds;
        }

        static double TestPropertiesInterface()
        {
            DateTime dtStart = DateTime.Now;
            int n;
            for (int i = 0; i < count; i++)
            {
                n = uniti[i].iX + uniti[i].iY; // 0
                n = uniti[i].iX + uniti[i].iY; // 1
                n = uniti[i].iX + uniti[i].iY; // 2
                n = uniti[i].iX + uniti[i].iY; // 3
                n = uniti[i].iX + uniti[i].iY; // 4
                n = uniti[i].iX + uniti[i].iY; // 5
                n = uniti[i].iX + uniti[i].iY; // 6
                n = uniti[i].iX + uniti[i].iY; // 7
                n = uniti[i].iX + uniti[i].iY; // 8
                n = uniti[i].iX + uniti[i].iY; // 9
            }
            DateTime dtEnd = DateTime.Now;
            return (dtEnd - dtStart).TotalMilliseconds;
        }
    }

    interface iUnit
    {
        int iX {get;}
        int iY {get;}
    }

    public class Unit : iUnit
    {
        public int x;
        public int X { get { return x; } }
        int iUnit.iX { get { return x; } }

        public int y;
        public int Y { get { return y; } }
        int iUnit.iY { get { return y; } }

        public Unit(int inX, int inY)
        {
            x = inX;
            y = inY;
        }
    }
}

Я не буду уделять внимание коду, пример достаточно детский. Скажу только то, что по 10 инструкций в каждом цикле сделано для контрастного выделения времени выполнения тела цикла, от самой инструкции цикла.
У меня программа отработала следующим образом:

На мой взгляд все достаточно наглядно. Самый скоростной способ это естественно обращение к полю класса на прямую.
А теперь поясню к чему рассказал и продемонстрировал прописную истину. Всем так же известно, что в разработке 3D, в отличие от бизнес, приложений особенно ярко выражена погоня за скоростью. Но тем не менее, специалисты начинающие(!) работать с XNA, уже как правило, достаточно уверенно себя ощущают в области C# разработки. Вот в этом то и заключается основной казус. Который объясняется тем фактом, что вся справочная и обучающая литература пестрит примерами описывающими доступ к полям классов через свойства. В следствии чего ребята начинают автоматически(!) применять данный подход во всех случаях. И там где это действительно необходимо, и где не очень. Да это хороший тон(!). Удобно перехватывать обращения к полю класса, обрабатывать возникающие при этом исключительные ситуации. Но не подходит для применения в 3D(!!!).
Не всегда можно быстро выдать столько информации по данному вопросу очередному собеседнику. Да и сейчас я описал вопрос не за пять минут, но в дальнейшем могу с легкостью ссылаться на себя :).

Часть 2-я. Та же песня с Microsoft'ом.

Не для кого не секрет, что я люблю поковырять рефлектором все, что меня хотя бы мало-мальски интересует. Добавлю то, что порой это приносит больше информации, чем например чтение непосредственно MSDN. Поэтому в довесок к первой части я решил привести один(!) пример из библиотеки XNA.
Рассмотрим XNA 3.1, виндовую библиотеку Microsoft.Xna.Framework.dll,
одноименный namespace, и пусть подопытным будет структура Vector3.
Вот часть кода данной структуры, в рамках которой мы сейчас и пообщаемся:


public struct Vector3
{
    public float X;
    public float Y;
    public float Z;
    ...
    private static Vector3 _one;
    public static Vector3 One
    {
        get
        {
               return _one;
        }
    }
    ...
    public Vector3(float x, float y, float z)
    {
        this.X = x;
        this.Y = y;
        this.Z = z;
    }
    ...
    static Vector3()
    {
        ...
        _one = new Vector3(1f, 1f, 1f);
    ...
    }
}

К полям X, Y и Z вопросов нет. Но обращаю ваше внимание на свойство One. По логике One возвращает единичный вектор постоянного значения. А вот тут по подробнее. Разум цепляется за формулировку "постоянное значение". Читаем MSDN и выясняем, что переменная или поле с постоянным значением может быть объявлена при помощи двух ключевых слов модификаторов доступа, которыми являются const и readonly. На всякий случай поясню формулировкой, переменная или поле постоянного значения бывает двух видов:
- const -> применяется при объявления полей и локальных переменных, постоянное значение присваивается на этапе компиляции, исключительно(!) при объявлении;
- readonly -> применяется при объявления полей, значение может присваивается как при объявлении, так и в конструкторе данного класса или структуры.
Но речь идет о поле постоянного значения которое не возможно рассчитать при компиляции, что накладывает ряд ограничений и в соответствии с рассматриваемым нами случаем, расширим формулировки:
- Модификатор static не допускается в объявлении константы;
- значение константы должно быть полностью вычислено во время компиляции;
- Единственными возможными значениями для констант ссылочных типов являются string и null;
Ясное дело на static ставим крест, он однозначно не подходит. А вот readonly наш размерчик! И как нельзя лучше вписывается в нашу ситуацию. Потому, заранее уже зная куда нас это приведет, предлагаю по тестировать и сравнить время чтения значения из свойства стандартной структуры с чтением значения из иначе построенной структуры.
Смотрим пример:


using System;
using Microsoft.Xna.Framework;
namespace TestFields
{
    class Program
    {

        static int count;

        static void Main(string[] args)
        {
            count = 10000000;
            Console.WriteLine("testStandartVector3 = " + 
                TestStandartVector3().ToString() + 
                " mc");
            Console.WriteLine("testMyVector3 = " + 
                TestMyVector3().ToString() + 
                " mc");
        }

        static double TestStandartVector3()
        {
            DateTime dtStart = DateTime.Now;
            Vector3 vec;
            for (int i = 0; i < count; i++)
            {
                vec = Vector3.One; // 0
                vec = Vector3.One; // 1
                vec = Vector3.One; // 2
                vec = Vector3.One; // 3
                vec = Vector3.One; // 4
                vec = Vector3.One; // 5
                vec = Vector3.One; // 6
                vec = Vector3.One; // 7
                vec = Vector3.One; // 8
                vec = Vector3.One; // 9
            }
            DateTime dtEnd = DateTime.Now;
            return (dtEnd - dtStart).TotalMilliseconds;
        }

        static double TestMyVector3()
        {
            DateTime dtStart = DateTime.Now;
            gVector3 vec;
            for (int i = 0; i < count; i++)
            {
                vec = gVector3.One; // 0
                vec = gVector3.One; // 1
                vec = gVector3.One; // 2
                vec = gVector3.One; // 3
                vec = gVector3.One; // 4
                vec = gVector3.One; // 5
                vec = gVector3.One; // 6
                vec = gVector3.One; // 7
                vec = gVector3.One; // 8
                vec = gVector3.One; // 9
            }
            DateTime dtEnd = DateTime.Now;
            return (dtEnd - dtStart).TotalMilliseconds;
        }
    }

    public struct gVector3
    {
        public float X;
        public float Y;
        public float Z;

        public static readonly gVector3 One;

        public gVector3(float x, float y, float z) 
        { 
            X = x;
            Y = y;
            Z = z;
        }

        static gVector3() 
        { 
            One = new gVector3(1, 1, 1);
        }
    }
}

Получаем вот такой вот результат:

Внимание вопрос(!): какая была необходимость реализовывать "постоянное значение" через свойство возвращающее значение приватного поля, если в сравнительном отношении скорости, с реализацией через модификатор доступа readonly, составляет разницу практически в(!) два раза? Мне не понятно, а вам? Буду очень признателен тому человеку, который вежливо мне объяснит.
Товарищам, которые планируют достаточно часто применять постоянные вектора:
- Zero;
- One;
- UnitX;
- UnitY;
- UnitZ;
- Up;
- Down;
- Right;
- Left;
- Forward;
- Backward.
Рекомендую не использовать стандартные, а реализовать самостоятельно, как в выше приведенном примере.
Мысль которую я хотел донести, звучит следующим образом:
- изучайте все средства, которые собираетесь применять в своих проектах;
- в результате изучения берите только лучшее и делайте наконец то сказку былью;
- не знание законов не освобождает от ответственности. Это про специалистов, которые по своей беспечности, не разбираясь, применяют все подряд, а в последствии сетуют на Microsoft. Хотя это говорит с плохой стороны не(!) о Microsoft.
- допуская то, что не смотря на "много букв", у читателей данной статьи мнения разойдутся. Я добавил третью часть. Читать рекомендую всем, только одним принять к сведению, а иным просто улыбнуться.

Часть 3-я философская. Охотник или жертва?

Жертвам своей не компетентности, которые любят плохо отзываться о Microsoft, посвящается.
Что, из себя, представляет понятие мода? Мода - в широком смысле этого слова, определяет стремление, того или иного человека, быть похожим на основное большинство. Хм, так то оно так, когда в меру, без фанатизма и крайностей. А так же не идет в разрез с законами эволюции, которые не зависимо от нас хранят приоритетное право "сильных" и "особенно удачных" особей выживать. К примеру обратная крайность это не формальные движения в нашем обществе.
Применяем выше описанное отступление к нашей основной теме. И так у нас есть три основных типа людей. Систематизируем их и результат оформим в виде структуры:
- ярко выражено не(!) довольные Microsoft'ом -> модные "жертвы". Да, уже более десяти лет считается модно и наверное круто так себя вести;
- фанаты Microsoft'а -> назовем их "панки", так веселее смотрится не формальное определение. Обычно эти люди либо являются специалистами, но узкого профиля, либо совсем не являются таковыми. Если кого то обидел, сообщите мне. Я подберу более мягкое определение.
- специалисты -> "охотники". Ни кому не покланяются, ни кого не ругают. Им некогда отвлекаться на разную чушь. Эти люди берут от жизни только лучшее, прекрасно понимая при этом как и где это лучшее применять, и как и где не стоит. Они же становятся MCP, MVP, "черными поясами" Intel, … , и другими почетными товарищами.

Заключение.

Ну вот и все. Всем перца насыпал. Развеялся. Можно дальше "охотиться" ... оговорился :) ... работать и точить свое мастерство.

XNA: Water video

2009-08-29T15:07:00.005+04:00

Рекомендую смотреть в режиме HD 1024x768

В данном исполнении нет каустики. Но сейчас я заинтересовался этой темой, нагреб кучу инфы, изучаю ... пробую.
Пока мои изыскания выглядят так:

Т.е. простое вычисление в один (сильно тяжелые вычисления для real time) проход на CPU.

Пока делал первое видео, в глаза бросилась вот какая штука. Изначально видео с водичкой весило 2,092 ГБ, конвертировал при помощи Camtasia Studio и как то сильно быстро изменялся прогресс конвертирования. Посмотрел загрузку процессоров ... и о чудо.

Camtasia Studio умеет распределять вычисления на все доступные процессоры.
Конвертация прошла в real time режиме :). Очень порадовало!

XNA: Water - проба пера

2009-08-24T22:56:00.003+04:00

Сферическая карта неба + пока простая водичка.
Превый блин, так сказать, в этом направлении.

Windows 7 RTM Now Available for MSDN and TechNet Plus Subscribers

2009-08-10T00:11:00.013+04:00

Windows 7 RTM стала доступна для подписчиков MSDN и TECHNET+

7 августа, для счастливых обладателей подписок MSDN Subscription и TECHNET Subscription стала доступна для скачивания Windows 7 RTM.

несколько строк из приглашения:
Dear ...
Как TechNet Плюс подписчик, Вы имеете преимущество того, чтобы быть среди первых в мире имеющих доступ к Windows 7 RTM.
Загрузите свою копию Windows 7 RTM и начните оценивать сегодня!
...
Windows Home Premium это - большой выбор для дома и для бизнеса.
...
Посетите Windows Springboard, полную последних ресурсов для Windows 7 включая ресурсы для прикладной совместимости, организации сети, работы и совместимости аппаратных средств, и много другого.

Мне крайне повезло иметь обе подписки. Очень рекомендую всем. Любая из этих подписок очень полезная штука.

Немного поясню для тех кто не знает что это.
-Во первых, платно подписаться может любой.
-Во вторых подписку можно получить в награду при определенных стечениях обстоятельств. Мне известно пока только об одной подобной возможности, т.к. сам получил обе подписки как бонус к награде MVP (Microsoft MVP, Кто такие MVP?, Кто такие RD и MVP?).
(пока писал, вспомнил о еще одной из без платных возможностей)
- программа для бизнеса BizSpark. Описание программы BizSpark, описание от Softline (партнера по сообществу BizSpark)

Что же такого интересного в этих подписках?
Коротко вкусности выглядят так:
-Обновленные продукты (6)
-Business Solutions (25)
-Библиотека MSDN (11)
-Операционные системы (29)
-Приложения (57)
-Серверы (65)
-Средства для разработчиков (42)
-Средства и ресурсы (105)
-Средства проектирования (4)

Там все, что вам нужно для счастья. Ко всему ПО (которое требует) там же можно получить ключи, скачать и оценить в полной мере. Под словами «в полной мере» я имею в виду установить, официально зарегистрировать, получить все обновления и в результате оценить продукт по достоинству в настоящем виде. Фишка не для дилетантов, а для людей ценящих свое время, силы и деньги. Переиначу известную поговорку - «Мы не на столько богаты, что бы тратить деньги на дешевые пиратские подделки».

Video: Animated Skinned Instancing

2009-07-17T14:21:00.005+04:00

У каждой модельки свой прогресс анимации.
Как то так.

UV координаты вершины принадлежащей треугольнику

2009-06-21T08:28:00.010+04:00

При сложном разбиении mesh’а (дополнительная генерация геометрии), треугольники дробятся таким образом, что текстурные координаты новых вершин бывает не так просто вычислить. Потому, что новая вершина может по разным причинам быть различно удаленной от вершин треугольника. Вспомнил, что как то приводил свой вывод расчета в форуме xnadev.ru, но как понадобилось самому, долго искал, где именно.

Делаю для себя заначку, чтоб добру не пропадать:


using System; 
using Microsoft.Xna.Framework; 

namespace Test 
{ 
 public class TestMath2 
 { 
 public TestMath2() 
 { 
 // вершины треугольника 
 Vector3 A = new Vector3(1f, -1f, 0f); 
 Vector3 B = new Vector3(3f, -4f, 0f); 
 Vector3 C = new Vector3(5f, -1f, 0f); 
 // текстурные координаты вершин 
 Vector2 tA = new Vector2(1f, 1f); 
 Vector2 tB = new Vector2(3f, 4f); 
 Vector2 tC = new Vector2(5f, 1f); 
 // точка в плоскости треугольника ограниченная его гранями 
 Vector3 D = new Vector3(3f, -2f, 0f); 
 //           B 
 //           . 
 //          / \ 
 //         /   \ 
 //        /     \ 
 //       /   .D  \ 
 //      /         \ 
 //     .-----------. 
 //  A               C 
 // расчет 
 Vector2 tD = CalculationDuvFromABC( A, tA, 
 B, tB, 
 C, tC, 
 D); 
 } 
 /// 
 /// Нахождение текстурных координат точки D 
 /// 
 /// Позиция точки A 
 /// Текстурные координаты точки A 
 /// Позиция точки B 
 /// Текстурные координаты точки B 
 /// Позиция точки C 
 /// Текстурные координаты точки C 
 /// Позиция точки D 
 /// Текстурные координаты точки D 
 private Vector2 CalculationDuvFromABC( Vector3 A, Vector2 tA, 
 Vector3 B, Vector2 tB, 
 Vector3 C, Vector2 tC, 
 Vector3 D) 
 { 
 Vector3 E = PointOfLinesCrossing(A, B, C, D); 
 float kAEC = (E - A).Length() / (C - A).Length(); 
 Vector2 tE = tA + (tC - tA) * kAEC; 
 float kBDE = (D - B).Length() / (E - B).Length(); 
 return (Vector2)(tB + (tE - tB) * kBDE); 
 } 
 /// 
 /// Нахождение позиции точки пересечения двух прямых, 
 /// проходящих через точки AC и BD 
 /// 
 /// Позиция точки A 
 /// Позиция точки B 
 /// Позиция точки C 
 /// Позиция точки D 
 /// Позиция точки E, полученной пересечением двух прямых AC и BD 
 private Vector3 PointOfLinesCrossing(Vector3 A, Vector3 B, Vector3 C, Vector3 D) 
 { 
 Vector3 vecAC = C - A; 
 Vector3 vecBD = D - B; 
 float Tac = Math.Abs( Matrix2x2Determinant( vecBD.X, A.X - B.X, 
 vecBD.Y, A.Y - B.Y) 
 / 
 Matrix2x2Determinant( vecBD.X, vecAC.X, 
 vecBD.Y, vecAC.Y)); 
 return Vector3.Add(A, Vector3.Multiply(vecAC, Tac)); 
 } 
 /// 
 /// Определитель матрицы 2х2 
 /// 
 /// a00 
 /// a01 
 /// a10 
 /// a11 
 /// Определитель 
 private float Matrix2x2Determinant( float a00, float a01, 
 float a10, float a11) 
 { 
 return (float)(a00 * a11 - a10 * a01); 
 } 
 } 
}

Процессор Intel® Core™ i7 (Nehalem)

2009-06-21T08:01:00.004+04:00

Вот уже чуть менее полу года такой кристалл (920) живет в моем доме. А чувство восторга не стало меньше. Свой вклад конечно же (подливает масла в огонь) вносит nVIDIA GeForce GTX 280. Вполне возможно это так же связанно с тем, что предыдущая смена железа была в далеком 2003 году. Кто знает.

Приведу список ссылок, где расписаны умения этого творения рук человеческих:

- i7 SDK (Software Development Key): ключ к разработке эффективных программ для новейшего процессора Intel Core i7 – подробный видео доклад доступен на www.techdays.ru. Докдладчик Victoria Zhislina работает в компании Intel с 1997 года и имеет экстремальный опыт создания графических библиотек и многопоточных приложений. В настоящее время занимается технической поддержкой компаний-разработчиков программного обеспечения, помогая им внедрить и эффективно использовать в своих продуктах возможности аппаратных платформ Intel (copy/paste).

- описание Intel’а

- википедия

P.S. если раньше не хватало процессоров, то сейчас самостоятельному Indie не хватает рук и времени …

Terrain Geomorphing in the Vertex Shader

2009-06-21T04:45:00.010+04:00

Читал несколько статей на эту тему. Искал с рабочими примерами (желательно на XNA + HLSL), конкретно с пред расчетом и готовым шейдером. Но нашел только много теории и не для XNA и DirectX, а в общем. Написано умно, ничего не понял. Конкретно озадачив себя, просидел как всегда допоздна. На утро, проснулся с готовым представлением о содержимом шейдера. Мне повезло.

Демонстрация:

И так по порядку.
Рассмотрим вот такую картинку:

Здесь изображен процесс перехода между уровнями детализации ландшафта.
черным цветом - контур геометрии предыдущего слоя детализации;
синим цветом – его вершины;
красным цветом – вершины нового уровня детализации.
зеленым цветом – выделен контур новой геометрии с учетом достроенных вершин, в следствии разбиения;
фиолетовым цветом – вершины середин отрезков между вершинами предыдущего слоя детализации;
красные вектора в низ – delta вектора разности между серединами отрезков вершин предыдущего слоя и соответствующими им новыми вершинами. Дальше по тексту разъясню подробнее.

Что из себя представляет «Terrain Geomorphing in the Vertex Shader»?
Если посмотреть более пристально на видео пример к моей предыдущей статье "Procedural Landscape on XNA Game Studio 3.0", где нет геоморфинга,то можно увидеть как «выпрыгивает» (новый научный термин) новая геометрия, при наезде друг на друга слоев с различной детализацией.

Это не есть good!

Легко избежать этого можно следующим образом:
- для каждой достраиваемой вершине в новом, более детализированном слое рассчитываем ее положение на середине отрезка построенного между соседними вершинами старого, менее детализированного слоя. Эта вершина поможет нам скрыть (замаскировать) первоначальную разницу изменения геометрии. И находим вектор разницу между этой вершиной и вершиной с реальным значением высоты. Вектор должен быть именно такого направления как показано на рисунке. Это даст нам возможность при его сложении с реальной вершиной опускать ее до уровня середины отрезка.

Нам понадобится следующее описание формата вершин для хранения выше описанных данных:


namespace gEngine.gProgressiveLandscape
{
    public struct gplVertexPositionNormalTexture
    {
        
        public Vector3  Position;
        public Vector3  PositionGeomorphing;
        public Vector3  Normal;
        public Vector3  NormalGeomorphing;
        public Vector2  TextureCoordinate;
        public float    IndexDetailedLayer;


        public static readonly VertexElement[] VertexElements;

        static gplVertexPositionNormalTexture()
        {
            VertexElements = new VertexElement[6];
            short offset    = 0;
            // Position
            VertexElements[0] = new VertexElement(0, offset, 
                                            VertexElementFormat.Vector3, 
                                            VertexElementMethod.Default, 
                                            VertexElementUsage.Position, 0);
            offset += (short)Marshal.SizeOf(new Vector3());
            // PositionGeomorphing
            VertexElements[1] = new VertexElement(0, offset, 
                                            VertexElementFormat.Vector3, 
                                            VertexElementMethod.Default, 
                                            VertexElementUsage.Position, 1);            // !
            offset += (short)Marshal.SizeOf(new Vector3());
            // Normal
            VertexElements[2] = new VertexElement(0, offset,
                                            VertexElementFormat.Vector3,
                                            VertexElementMethod.Default,
                                            VertexElementUsage.Normal, 0);
            offset += (short)Marshal.SizeOf(new Vector3());
            // NormalGeomorphing
            VertexElements[3] = new VertexElement(0, offset,
                                            VertexElementFormat.Vector3,
                                            VertexElementMethod.Default,
                                            VertexElementUsage.Normal, 1);              // !
            offset += (short)Marshal.SizeOf(new Vector3());
            // TextureCoordinate
            VertexElements[4] = new VertexElement(0, offset,
                                            VertexElementFormat.Vector2,
                                            VertexElementMethod.Default,
                                            VertexElementUsage.TextureCoordinate, 0);
            offset += (short)Marshal.SizeOf(new Vector2());
            // NamberDetailedLayer
            VertexElements[5] = new VertexElement(0, offset,
                                            VertexElementFormat.Single,
                                            VertexElementMethod.Default,
                                            VertexElementUsage.TextureCoordinate, 1);   // !
        }

        public gplVertexPositionNormalTexture(  Vector3 position,
                                                Vector3 positionGeomorphing,
                                                Vector3 normal,
                                                Vector3 normalGeomorphing,
                                                Vector2 textureCoordinate,
                                                float indexDetailedLayer)
        {
            this.Position               = position;
            this.PositionGeomorphing    = positionGeomorphing;
            this.Normal                 = normal;
            this.NormalGeomorphing      = normalGeomorphing;
            this.TextureCoordinate      = textureCoordinate;
            this.IndexDetailedLayer     = indexDetailedLayer;
        }

        public static int SizeInBytes
        {
            get
            {
                return (int)(   Marshal.SizeOf(new Vector3()) + 
                                Marshal.SizeOf(new Vector3()) +
                                Marshal.SizeOf(new Vector3()) +
                                Marshal.SizeOf(new Vector3()) +
                                Marshal.SizeOf(new Vector2()) +
                                sizeof(float));
            }
        }
    }
}

Здесь PositionGeomorphing и есть то поле для хранения вектора смещения.

Нечто похожее делаем и с нормалями.

Все волшебство произойдет в шейдере!

Куда мы передадим дополительную информацию о:
float3 vEyePosition; - положении камеры
float layerRadius[7]; - реальные размеры уровней детализации

Для каждой вершины будем считать удаление от камеры, по ее индексу выбирать данные, из массива размеров уровней детализации, для расчета коэффициента затухания вектора PositionGeomorphing.

Сам шейдер выглядит следующим образом:


float4x4 matWorld   : WORLD;
float4x4 matWVP     : WORLDVIEWPROJECTION;

float3  vLightPosition;
float3  vEyePosition;

float  layerRadius[7];

float fogBegin = 200.0f;
float fogEnd = 400.0f;

struct VS_INPUT
{
    float3 Position             : POSITION0;
    float3 PositionGeomorphing  : POSITION1;
    float3 Normal               : NORMAL0;
    float3 NormalGeomorphing    : NORMAL1;
    float2 Texcoord             : TEXCOORD0;
 float IndexDetailedLayer  : TEXCOORD1;
};

struct VS_OUTPUT
{
    float4 Position    : POSITION0;
    float2 Texcoord    : TEXCOORD0;
    float3 Light       : TEXCOORD1;
    float3 Normal      : TEXCOORD2;
 float Fog      : TEXCOORD3; 
};

VS_OUTPUT VS(VS_INPUT In)
{
    VS_OUTPUT Out = ( VS_OUTPUT ) 0;
 float Distance = length ( In.Position - vEyePosition );
 float K   = clamp  ((( Distance / layerRadius[In.IndexDetailedLayer] - 0.5f ) * 2.0f ), 0.0f, 1.0f );
    Out.Position = mul  ( float4(In.Position + In.PositionGeomorphing * K, 1.0f ), matWVP );
    Out.Fog   = clamp  ((( 1.0f - (Distance - fogBegin) / fogEnd) - 0.5f) * 2.0f, 0.0f, 1.0f);
 //Out.Fog = 1.0f;
    Out.Texcoord = In.Texcoord;
    Out.Light  = normalize ( mul(vLightPosition, matWorld) );
    Out.Normal  = normalize ( mul( In.Normal + In.NormalGeomorphing * K, matWorld ) ); 
    return Out;
}

texture tex;
sampler2D sTexture = sampler_state
{
   Texture = (tex);
};

float spec = 0.5f;

float4 PS(VS_OUTPUT In) : COLOR0
{
 float4 specColor = tex2D( sTexture, In.Texcoord ) * spec;
 float4 diffColor = clamp( tex2D( sTexture, In.Texcoord ) * dot( In.Normal, In.Light ), 0.0f, 1.0f );
 float4 color  = float4(1.0f, 1.0f, 1.0f, 1.0f) * (1.0f - In.Fog) + (diffColor + specColor) * In.Fog;
 return color;
}

technique TerrainGeomorphing
{
    pass Pass1
    {
        VertexShader = compile vs_3_0 VS();
        PixelShader  = compile ps_3_0 PS();
    }
}

Да, в шейдере добавлен расчет тумана, его можно выбросить. Он влияет только на текстурирование.

Оригинальный блог

Procedural Landscape on XNA Game Studio 3.0

2009-06-21T00:40:00.014+04:00

Динамический ландшафт

Демонстрация:

На видео я намеренно включаю рисование сетки треугольников и поднимаю камеру над ландшафтом. Для наглядности так же выключил, из расчета, определение видимых слоев детализации по мере взлета, потому видно все. Обращаем внимание на fps (когда камера высоко не в счет, по выше описанной причине)

Закончил эту часть работы давно. Даже успели обсудить на xnadev.ru . Сейчас данный проект уже несколько раз преобразился. Возможно, в скором времени, дойдут руки сделать новое видео. Как раз будет повод рассказать о том, что из себя представляет «Terrain Geomorphing in the Vertex Shader» и с чем его едят. Пока расскажу об этом этапе.

Как это делалось?

Описал представление слоев детализации и данных о вершинах.
Карта логики представления слоев детализации выглядит так:

Карта логики связывания вершин слоев детализации в треугольники, с учетом связей между соседними слоями выглядит так:

На обеих картинках цвета слоев не совпадают. Лень переделывать. Просто остались наработанные картинки, которые изначально не предназначались для статьи.

Для каждого слоя детализации происходит проверка изменения положения камеры. Если произошло смещение на расстояние равное шагу данного слоя детализации, значит этот слой участвует в рекурсивной генерации новых данных для индексного буфера. Данный механизм запускается в отдельном потоке каждый раз, когда помечается на обновление слой с самой высокой детализацией. А далее проверяется выше описанное условие для остальных слоев.
В потоке выполняются следующие операции:

private void backgroundWorker_DoWork
(object sender, DoWorkEventArgs e)
{
PartitionLevels();
geometry.InitIndex();
geometry.GenNormal();
}

- разбиение слоев детализации, добавление новых вершин (и корректировка их высот) в единый массив вершин;
- инициализация единого массива индексов, связывающих все треугольники (вершины), всех слоев детализации.
- генерация нормалей.

На пальцах все это выглядит просто, для оценки реализации приведу пример рекурсивного метода, рассчитывающего интервал значений индексного массива, соответствующего ветке дерева визуализации нулевого слоя детализации.
Честное слово, мне проще код писать, чем слова в предложения собирать. Не ругайте сильно, но по другому мне сложно коротко сформулировать ту кучу "каракуль", которыми я исписал свой блокнот, занимаясь данной темой.
Нулевым в данном случае является слой наименьшей детализации. Что бы окончательно Вас запутать. Скажу что понятия уровней детализации и дерева детализации тесно сплетены между собой. Дерево это восходящие, из слоя нулевой детализации, ветви связей перпендикулярно пересекающие по иерархии старшинства следующие уровни (плоскости) детализации, разделяясь в точке пересечения на четыре наследника. Потому Quad tree. Зачем все так сложно? Зачем представление в виде дерева и плоскостей? Все просто. Каждое представление для выполнения различных задач. Каждые задачи наиболее быстро выполняются только в одном из представлений. Плоскости для линейных задач, дерево для рекурсивных и отслеживания наследственных связей. Выше упомянутый обещанный рекурсивный метод возвращает все индексы всех треугольников ограниченных габаритами одной ветки нулевого слоя детализации.

Блок схема обещанного метода:

Блок схема автоматически сгенерирована примочкой к Visual Studio под названием «Microsoft Visual Studio Learning Pack 2.0»

Код метода:


Код метода:
/// 
/// Рекурсивная сборка индексов отдельной ветки дерава уровней детализации ландшафта
/// 
private void InitNodeIndex (gplNode inNode, ref int inIndex)
{
// --- уровень детализации ---------------------------------------
int l = inNode.Level;
// --- индекс активной ветки --------------------------------------
int i = inNode.Index;
// --- размеры активного уровня детализации -----------------------
int w = levelInfo[l].W;
int h = levelInfo[l].H;
// --- признаки соединение со слоем более низкой детализации ------
bool bLeft = false;
bool bRight = false;
bool bUp = false;
bool bDown = false;
// --- индексные направления слоя для псевдодвухмерной карты ------
gxplTrends trends = new gxplTrends();
trends.NewTrends(i, w);
// --- если ветка не разбита ----------------------------------------------------------------------------------------
if (inNode.NodeChildren == null)
{
// --------------------------------------------------------------------------------------------------------------
#region --- собираем два треугольника ---------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
// - 1й треугольник -----------------------
indices[inIndex + 0] = trends.Center;
indices[inIndex + 1] = trends.Right;
indices[inIndex + 2] = trends.Down;
// - 2й треугольник -----------------------
indices[inIndex + 3] = trends.Down;
indices[inIndex + 4] = trends.Right;
indices[inIndex + 5] = trends.DownRight;
inIndex += 6;
// --------------------------------------------------------------------------------------------------------------
#endregion ------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
}
// --- если разбита -------------------------------------------------------------------------------------------------
else
{
// --------------------------------------------------------------------------------------------------------------
#region --- определение режима соединения с соседними ветками ---------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
// --- check left join --------------------------------------------
//if (!bNoLeft)
bLeft = (inNode.Coord.X > levelInfo[l].SX0) ?
map[trends.Left].NodeChildren == null : true;
// --- check right join -------------------------------------------
//if (!bNoRight)
bRight = (inNode.Coord.X < levelInfo[l].SX0 + levelInfo[l].W - 1) ?
map[trends.Right].NodeChildren == null : true;
// --- check up join ----------------------------------------------
//if (!bNoUp)
bUp = (inNode.Coord.Y > levelInfo[l].SY0) ?
map[trends.Up].NodeChildren == null : true;
// --- check down join --------------------------------------------
//if (!bNoDown)
bDown = (inNode.Coord.Y < levelInfo[l].SY0 + levelInfo[l].H - 1) ?
map[trends.Down].NodeChildren == null : true;
// --------------------------------------------------------------------------------------------------------------
#endregion ------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
#region --- сборка всех треугольников с учетом связей различных слоев детализации -------------------------------
// --------------------------------------------------------------------------------------------------------------
// --- индексные направления слоя +1 для псевдодвухмерной карты -------------------------
gxplTrends trends4x3 = new gxplTrends(inNode.NodeChildren[3].Index, levelInfo[l + 1].W);
// --------------------------------------------------------------------------------------------------------------
#region --- если с лева соединение с более высокой детализацией --------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
if (bLeft)
{
indices[inIndex + 0] = trends.Center;
indices[inIndex + 1] = trends4x3.Center;
indices[inIndex + 2] = trends.Down;
inIndex += 3;
// --- если с верху нет! соединения с более высокой детализацией (добавочный треугольник)
if (!bUp)
{
indices[inIndex + 0] = trends.Center;
indices[inIndex + 1] = trends4x3.Up;
indices[inIndex + 2] = trends4x3.Center;
inIndex += 3;
}
// --- если с низу нет! соединения с более высокой детализацией (добавочный треугольник)
if (!bDown)
{
indices[inIndex + 0] = trends.Down;
indices[inIndex + 1] = trends4x3.Center;
indices[inIndex + 2] = trends4x3.Down;
inIndex += 3;
}
}
else // если нет соединение с более высокой детализацией, то переходим к следующему уровню детализации
{
if (!bUp) // Х0
InitNodeIndex(inNode.NodeChildren[0], ref inIndex); // 00

if (!bDown) // 00
InitNodeIndex(inNode.NodeChildren[2], ref inIndex); // Х0
}
// --------------------------------------------------------------------------------------------------------------
#endregion ------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
#region --- если с права соединение с более высокой детализацией ------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
if (bRight)
{
indices[inIndex + 0] = trends.Right;
indices[inIndex + 1] = trends.DownRight;
indices[inIndex + 2] = trends4x3.Center;
inIndex += 3;
// --- если с верху нет! соединения с более высокой детализацией (добавочный треугольник)
if (!bUp)
{
indices[inIndex + 0] = trends4x3.Center;
indices[inIndex + 1] = trends4x3.Up;
indices[inIndex + 2] = trends.Right;
inIndex += 3;
}
// --- если с низу нет! соединения с более высокой детализацией (добавочный треугольник)
if (!bDown)
{
indices[inIndex + 0] = trends4x3.Center;
indices[inIndex + 1] = trends.DownRight;
indices[inIndex + 2] = trends4x3.Down;
inIndex += 3;
}
}
else // если нет соединение с более высокой детализацией, то переходим к следующему уровню детализации
{
if (!bUp) // 0Х
InitNodeIndex(inNode.NodeChildren[1], ref inIndex); // 00

if (!bDown) // 00
InitNodeIndex(inNode.NodeChildren[3], ref inIndex); // 0Х
}
// --------------------------------------------------------------------------------------------------------------
#endregion ------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
#region --- если с верху соединение с более высокой детализацией ------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
if (bUp)
{
indices[inIndex + 0] = trends.Center;
indices[inIndex + 1] = trends.Right;
indices[inIndex + 2] = trends4x3.Center;
inIndex += 3;
// --- если с лева нет! соединения с более высокой детализацией (добавочный треугольник)
if (!bLeft)
{
indices[inIndex + 0] = trends.Center;
indices[inIndex + 1] = trends4x3.Center;
indices[inIndex + 2] = trends4x3.Left;
inIndex += 3;
}
// --- если с права нет! соединения с более высокой детализацией (добавочный треугольник)
if (!bRight)
{
indices[inIndex + 0] = trends4x3.Center;
indices[inIndex + 1] = trends.Right;
indices[inIndex + 2] = trends4x3.Right;
inIndex += 3;
}
}
// --------------------------------------------------------------------------------------------------------------
#endregion ------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
#region --- если с низу соединение с более высокой детализацией -------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
if (bDown)
{
indices[inIndex + 0] = trends.Down;
indices[inIndex + 1] = trends4x3.Center;
indices[inIndex + 2] = trends.DownRight;
inIndex += 3;
// --- если с лева нет! соединения с более высокой детализацией (добавочный треугольник)
if (!bLeft)
{
indices[inIndex + 0] = trends4x3.Center;
indices[inIndex + 1] = trends.Down;
indices[inIndex + 2] = trends4x3.Left;
inIndex += 3;
}
// --- если с права нет! соединения с более высокой детализацией (добавочный треугольник)
if (!bRight)
{
indices[inIndex + 0] = trends4x3.Center;
indices[inIndex + 1] = trends4x3.Right;
indices[inIndex + 2] = trends.DownRight;
inIndex += 3;
}
}
//else
//{
//
//}
// --------------------------------------------------------------------------------------------------------------
#endregion ------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
#endregion ------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------
}
}

Свои задачи данная разработка уже выполнила. Для себя дальнейшие пути развития данной идеи я вижу два:
1) Растачивать дальше в этом направлении. Реализовать динамическую подгруздку данных о высотах с диска. Есть расчетные таблицы. Разработан алгоритм быстрого обновления кэшей высот к уровням детализации, без смещения (move) данных. Это позволит работать с ландшафтами огромного размера. Приведу пример расчета размеров LOD’ов для карты 1310.72^2 км с максимальной детализацией до 10^2 м:

2) Для игр. Придется переделать исходную коллекцию массивов высот в один. И реализовать новую выборку.

Вот как то так.

Оригинальный блог

Content Processor for Normal Map Texture

2009-06-20T23:41:00.000+04:00

Пахомов Андрей (PAX), на основе моей статьи Calculation deep normal map, сделал (для XNA Game Studio приложений) свой Content Processor для загрузки, через Content Manager, и пересчета текстуры в карту нормалей.

Скачать можно тут (требуется регистрация xnadev.ru)

Оригинал блога

Effect “Bump mapping”

2009-06-20T19:24:00.001+04:00

В этой статье своей целью я ставлю попытку, по своему, раскрыть суть данного эффекта, более подробно и доступно чем это делалось ранее, кем бы то ни было и с реализацией на XNA GS. Так, что бы было понятно начинающим. По максимуму охватить опорные моменты и используемые инструменты, а так же из собственного опыта нюансы, которые могут возникнуть.

И так поехали.

Для чистоты эксперимента рассмотрим частный случай.

Описание условий эксперимента:
Объект – (Поверхность текстурирования) плоскость, квадрат.
Расположение объекта – (изначальное) параллельно плоскости экрана, лицом к камере.
Карта нормалей – (текстура) для ее построения используем расчет, приведенный в моей статье «Calculation deep normal map».

Нам потребуется новый тип описания формата вершин, назовем его VertexPositionTangentSpaceTexture.

(код его реализации)
public struct VertexPositionTangentSpaceTexture
{
public Vector3 Position;
public Vector3 Normal;
public Vector3 Binormal;
public Vector3 Tangent;
public Vector2 TextureCoordinate;
public static readonly VertexElement[] VertexElements;
static VertexPositionTangentSpaceTexture()
{
VertexElements = new VertexElement[5];
short offset = 0;
// Position
VertexElements[0] = new VertexElement(
0, offset,
VertexElementFormat.Vector3,
VertexElementMethod.Default,
VertexElementUsage.Position,
0);
offset += (short)Marshal.SizeOf(new Vector3());
// Normal
VertexElements[1] = new VertexElement(
0, offset,
VertexElementFormat.Vector3,
VertexElementMethod.Default,
VertexElementUsage.Normal,
0);
offset += (short)Marshal.SizeOf(new Vector3());
// Binormal
VertexElements[2] = new VertexElement(
0, offset,
VertexElementFormat.Vector3,
VertexElementMethod.Default,
VertexElementUsage.Binormal,
0);
offset += (short)Marshal.SizeOf(new Vector3());
// Tangent
VertexElements[3] = new VertexElement(
0, offset,
VertexElementFormat.Vector3,
VertexElementMethod.Default,
VertexElementUsage.Tangent,
0);
offset += (short)Marshal.SizeOf(new Vector3());
// TextureCoordinate
VertexElements[4] = new VertexElement(
0, offset,
VertexElementFormat.Vector2,
VertexElementMethod.Default,
VertexElementUsage.TextureCoordinate,
0);
}
public VertexPositionTangentSpaceTexture(
Vector3 position,
Vector3 normal,
Vector3 binormal,
Vector3 tangent,
Vector2 textureCoordinate)
{
this.Position = position;
this.Normal = normal;
this.Binormal = binormal;
this.Tangent = tangent;
this.TextureCoordinate = textureCoordinate;
}
public static int SizeInBytes
{
get
{
return (int)( Marshal.SizeOf(new Vector3()) +
Marshal.SizeOf(new Vector3()) +
Marshal.SizeOf(new Vector3()) +
Marshal.SizeOf(new Vector3()) +
Marshal.SizeOf(new Vector2()));
}
}
}
В его описании поля: Normal, Binormal и Tangent. Послужат нам описанием локальной системы координат для каждой вершины, так называемый tangent space – пространство косательной. В данном примере мы не будем ударятся в оптимизацию и экономию. Потому для наглядности примера используем все три вектора и тем самым заострим внимание на самой сути Bump Map’инга и возможно это помежет кому либо избежать подводных камней при изучении этого примера.

Генерируем поверхность с вершинами типа VertexPositionTangentSpaceTexture.

(пример)
public void Quad()
{
float y0 = 0.5f;
float y1 = -y0;
float x0 = -0.5f;
float x1 = -x0;
float z0 = 0.5f;
float z1 = -z0;
z0 = 0; z1 = 0;
verts = new VertexPositionTangentSpaceTexture[4];
indices = new int[6];
int iv, ii;
iv = 0;
ii = 0;
// front
verts[iv + 0].Position = new Vector3(x0, y0, z0);
verts[iv + 1].Position = new Vector3(x1, y0, z0);
verts[iv + 2].Position = new Vector3(x0, y1, z0);
verts[iv + 3].Position = new Vector3(x1, y1, z0);
verts[iv + 0].Normal = Vector3.Backward;
verts[iv + 1].Normal = Vector3.Backward;
verts[iv + 2].Normal = Vector3.Backward;
verts[iv + 3].Normal = Vector3.Backward;
verts[iv + 0].Binormal = Vector3.Up;
verts[iv + 1].Binormal = Vector3.Up;
verts[iv + 2].Binormal = Vector3.Up;
verts[iv + 3].Binormal = Vector3.Up;
verts[iv + 0].Tangent = Vector3.Right;
verts[iv + 1].Tangent = Vector3.Right;
verts[iv + 2].Tangent = Vector3.Right;
verts[iv + 3].Tangent = Vector3.Right;
verts[iv + 0].TextureCoordinate = Vector2.Zero;
verts[iv + 1].TextureCoordinate = Vector2.UnitX;
verts[iv + 2].TextureCoordinate = Vector2.UnitY;
verts[iv + 3].TextureCoordinate = Vector2.One;
indices[ii + 0] = iv + 0;
indices[ii + 1] = iv + 1;
indices[ii + 2] = iv + 2;
indices[ii + 3] = iv + 2;
indices[ii + 4] = iv + 1;
indices[ii + 5] = iv + 3;
iv += 4;
ii += 6;
// verts
vertexBuffer = new VertexBuffer(
graphics.GraphicsDevice,
VertexPositionTangentSpaceTexture.SizeInBytes * verts.Length,
BufferUsage.None);
vertexBuffer.SetData(verts);
// index
indexBuffer = new IndexBuffer(
graphics.GraphicsDevice,
sizeof(int) * indices.Length,
BufferUsage.None, IndexElementSize.ThirtyTwoBits);
indexBuffer.SetData(indices);
vertexDeclaration = new VertexDeclaration(graphics.GraphicsDevice, VertexPositionTangentSpaceTexture.VertexElements);
}
}

Обращаю Ваше внимание на инициализацию опять же Normal, Binormal и Tangent. Фишка в том, что по условиям эксперимента я заранее знаю как будет расположен в пространстве текстурируемый объект. Потому так же знаю как будет расположенна нормаль к его лицевой стороне и соответствующие ей Binormal и Tangent.

В случае же со сложной, изогнутой поверхностью с большим количеством треугольников нам прийдется выполнять не простые вычисления для расчета tangent space к каждой вершине. Так же учитывать углы между плоскостями треугольников с общими вершинами и либо усреднять tangent space при малых углах, либо добовлять новые вершины для разделения значений tangent space соответствующие этим же треугольникам при углах близких к 90 градусам. Но это уже развитие идеи и большая тема для отдельной статьи.

Для чего нам это нужен tangent space?
Все просто. Как вы наверно знаете, в вершинном шейдере при обычном текстурировании, для правильного проецирования в плоскость экрана, мы выполняем следующие преобразования:

(пример)
Out.Position = mul( In.Position, matWVP );
Out.Light = normalize( vLight );
Out.Normal = normalize( mul( In.Normal, matWorld ) );
Out.Texcoord = In.Texcoord;

Т.е.
- преобразуем и проецируем координаты вершины в плоскость экрана матрицей matWVP (семантика :WORLDVIEWPROJECTION);
- преобразуем нормали матрицей matWorld (семантика :WORLD) – поворот нормалей для правильного расчета освещения в пиксельном шейдере;

Но в нашем случае нормали к вершинам поворачивать мы не будем. Потому, что это влечет за собой поворот всех нормалей, к каждому пикселю текстуры, принадлежащих выводимым треугольникам, а это лишние действия. Классический прием - поворот вектора освещения обратно повороту объекта, вот так:

(пример)
float3 vLight = mul(vLightPos, matWorldBack) - In.Position;
//float3 tangent = float3(1,0,0); \
//float3 binormal = float3(0,1,0); - в нашем частном случае
//float3 normal = float3(0,0,1); /
float3 normal = normalize(In.Normal);
float3 binormal = normalize(In.Binormal);
float3 tangent = normalize(In.Tangent);
float3x3 matTS = float3x3(tangent, binormal, normal);
Out.vLightTS = normalize(mul(vLight, matTS));

Мы поворачиваем вектор источника света vLightPos в соответствии с преобразованиями накопленными в матрице matWorldBack. Эта матрица является обратной матрицей для мировой матрицы объекта. Прернос и масштабирование в данном случае нас не интересуют, потому как vLightPos вектор, а не координата, и мы нормализуем итоговый результат.
Что значит обратная матрица? Матрица в которой собраны преобразования обратные оригинальной матрице. В данном случае с помощью обратной матрицы мы вращаем вектор освещения в сторону обратную вращению нашего объекта.
Получить обратную матрицу средствами XNA очень просто:
matWorldBack = Matrix.Invert(matWorld);
Далее переводим координаты источника света (в статичную!) локальную систему координат очередной вершины действиями:
float3 normal = normalize(In.Normal);
float3 binormal = normalize(In.Binormal);
float3 tangent = normalize(In.Tangent);
float3x3 matTS = float3x3(tangent, binormal, normal);
Out.vLightTS = normalize(mul(vLight, matTS));
Где, matTS – матрица описывающая tangent space вершины.

После чего мы готовы к текстурированию с учетом освещения и псевдо рельефа.
В пиксельном шейде (пример):
float4 ps(PS_INPUT In) : COLOR0
{
float3 vNormalTS = tex2D( sTexture0, In.Texcoord ) * 2 - 1;
float4 color = float4(0.8f, 0.8f, 0, 1);
float3 vlightTS = In.vLightTS;

float light = clamp(dot(vNormalTS, vlightTS), 0, 1);
return mul(color, light);
}
Стоит обратить внимание на две строчки:
1) float3 vNormalTS = tex2D( sTexture0, In.Texcoord ) * 2 - 1;
где, мы берем нормаль к поверхности в данном пикселе текстуры и распаковываем ее в первоначальный вид, т.к. в normal map у нас хранятся данные о (естественно) нормалях, но упакованными по условной формуле:
color = normal * 0.5f + vector(0.5f, 0.5f, 0.5f);
Подробнее смотреть статью о расчете - «Calculation deep normal map».
2) float light = clamp(dot(vNormalTS, vlightTS, 0, 1);
сам расчет интенсивности освещения для данного пикселя текстуры.

(полный пример шейдера)
float4x4 matWorld : WORLD0;
float4x4 matWorldBack : WORLD1;
float4x4 matWVP : WORLDVIEWPROJECTION0;
float3 vLightPos;
float3 vViewPos;
struct VS_INPUT
{
float3 Position : POSITION0;
float3 Normal : NORMAL0;
float3 Binormal : BINORMAL0;
float3 Tangent : TANGENT0;
float2 Texcoord : TEXCOORD0;
};
struct VS_OUTPUT
{
float4 Position : POSITION0;
float2 Texcoord : TEXCOORD0;
float3 vLightTS : TEXCOORD3;
};
VS_OUTPUT vs( VS_INPUT In )
{
float3 vLight = mul(vLightPos, matWorldBack) - In.Position;
float3 normal = normalize(In.Normal);
float3 binormal = normalize(In.Binormal);
float3 tangent = normalize(In.Tangent);
float3x3 matTS = float3x3( tangent, binormal, normal );
VS_OUTPUT Out = ( VS_OUTPUT ) 0;
Out.Position = mul(float4( In.Position, 1 ), matWVP);
Out.Texcoord = In.Texcoord;
Out.vLightTS = normalize(mul(vLight, matTS));
return Out;
}
texture tex0;
sampler2D sTexture0 = sampler_state
{
Texture = (tex0);
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = CLAMP;
AddressV = CLAMP;
};
struct PS_INPUT
{
float2 Texcoord : TEXCOORD0;
float3 vLightTS : TEXCOORD3;
};
float4 ps(PS_INPUT In) : COLOR0
{
float3 vNormalTS = tex2D( sTexture0, In.Texcoord ) * 2 - 1;
float4 color = float4(0.8f, 0.8f, 0, 1);
float3 vlightTS = In.vLightTS;
float light = clamp(dot(vNormalTS, vlightTS), 0, 1);
return mul(color, light);
}
{
pass Pass_0
{
VertexShader = compile vs_2_0 vs();
PixelShader = compile ps_2_0 ps();
}
}

Результат:

Абсолютно прозрачные и простые примеры это хорошо. Но закончить статью хочется ярче. Потому поковыряв в приложении к RenderMonkey пример «Parallax Occlusion Mapping». Я добавил бликовую модель освещения и тут же картинка (ее можно увидеть в начале статьи) стала живее.
(пример шейдера)

float4x4 matWorld : WORLD0;
float4x4 matWorldBack : WORLD1;
float4x4 matWVP : WORLDVIEWPROJECTION0;
float3 vLightPos;
float3 vViewPos;
struct VS_INPUT
{
float3 Position : POSITION0;
float3 Normal : NORMAL0;
float3 Binormal : BINORMAL0;
float3 Tangent : TANGENT0;
float2 Texcoord : TEXCOORD0;
};
struct VS_OUTPUT
{
float4 Position : POSITION0;
float2 Texcoord : TEXCOORD0;
float3 vNormalWS : TEXCOORD1;
float3 vViewWS : TEXCOORD2;
float3 vLightTS : TEXCOORD3;
float3 vViewTS : TEXCOORD4;
};
VS_OUTPUT vs( VS_INPUT In )
{
float3 vLight = mul(vLightPos, matWorldBack) - In.Position;
float3 vViewDir = mul(vViewPos, matWorldBack) - In.Position;
float3 normal = normalize(In.Normal);
float3 binormal = normalize(In.Binormal);
float3 tangent = normalize(In.Tangent);
float3x3 matTS = float3x3( tangent, binormal, normal );
VS_OUTPUT Out = ( VS_OUTPUT ) 0;
Out.Position = mul(float4( In.Position, 1 ), matWVP);
Out.Texcoord = In.Texcoord;
Out.vNormalWS = In.Normal;
Out.vViewWS = vViewDir;
Out.vLightTS = normalize(mul(vLight, matTS));
Out.vViewTS = normalize(mul(vViewDir, matTS));
return Out;
}
texture tex0;
sampler2D sTexture0 = sampler_state
{
Texture = (tex0);
MinFilter = LINEAR;
MagFilter = LINEAR;
MipFilter = LINEAR;
AddressU = CLAMP;
AddressV = CLAMP;
};
struct PS_INPUT
{
float2 Texcoord : TEXCOORD0;
float3 vNormalWS : TEXCOORD1;
float3 vViewWS : TEXCOORD2;
float3 vLightTS : TEXCOORD3;
float3 vViewTS : TEXCOORD4;
};
float4 cSpecularColor = float4(1, 1, 1, 1);
float fSpecularExponent = 300;
float4 ps(PS_INPUT In) : COLOR0
{
float3 vNormalTS = tex2D( sTexture0, In.Texcoord ) * 2 - 1;
float4 color = float4(0.8f, 0.8f, 0, 1);
float3 vlightTS = In.vLightTS;
float3 vReflectionTS = normalize( 2 * dot( In.vViewTS, vNormalTS ) * vNormalTS - In.vViewTS );
float fRdotL = dot( vReflectionTS, In.vLightTS );
float4 cSpecular = saturate( pow( fRdotL, fSpecularExponent )) * cSpecularColor;
float light = clamp(dot(vNormalTS, vlightTS) * (color + cSpecular), 0, 1);
return mul(color, light);
}
technique BumpMapping
{
pass Pass_0
{
VertexShader = compile vs_2_0 vs();
PixelShader = compile ps_2_0 ps();
}
}

Скачать пример можно тут (требуется регистрация xnadev.ru) (чуть позже, в оригинальном блоге, ссылка станет доступна)

Оригинал блога

Calculation deep normal map

2009-06-19T23:13:00.000+04:00

Calculation normal map for “Bump mapping” & “Parallax Mapping” II

Вот еще один, более сложный пример расчета.

Что тут добавлено:
I. При расчете переворачивается ось Y, для приведения соответствующего tangent space к нормальному виду.
Это связанно с тем, что в мировой системе координат ось Y смотрит в верх, а в текстуре в низ.
II. Сглаживание normal map
III. Масштабирование для получения более глубокого эффекта.

(код примера)
///

/// Расчет normal map к текстуре
///

/// Текстура для расчета (цветная, черно-белая - по барабану)
/// Во сколько целых раз нужно уменьшить (2^n)
/// Рассчитанная normal map текстура
private Texture2D GenNormalMamp(Texture2D inTex, int K)
{
int inX = inTex.Width;
int inY = inTex.Height;
int outX = inTex.Width / K;
int outY = inTex.Height / K;
float z = 1;
int l = inX * inY;
Texture2D outTex = new Texture2D(graphics.GraphicsDevice, outX, outY);
Color[] inColor = new Color[l];
Color[] outColor = new Color[l / (K * K)];
float[,] heightMap = new float[outX, outY];
Vector3[,] normalMap = new Vector3[outX, outY];
inTex.GetData(inColor);
// height map
for (int iy = 0; iy < outY; iy++)
{
for (int ix = 0; ix < outX; ix++)
{
Vector3 v3 = inColor[iy * inX * K + ix * K].ToVector3();
heightMap[ix, iy] = (v3.X + v3.Y + v3.Z) / 3;
}
}
// normal map
float[] delHeight = new float[8];
Vector3[] v38 = new Vector3[8];
Vector3 vAddPack = new Vector3(0.5f, 0.5f, 0.5f);
Vector3 vScale = new Vector3(2f, 2f, 1f);
for (int iy = 0; iy < outY; iy++)
{
for (int ix = 0; ix < outX; ix++)
{
if (iy == 0 || iy == outY - 1 || ix == 0 || ix == outX - 1)
{
normalMap[ix, iy] = Vector3.Backward;
continue;
}
delHeight[0] = heightMap[ix, iy] - heightMap[ix - 1, iy - 1];
delHeight[1] = heightMap[ix, iy] - heightMap[ix, iy - 1];
delHeight[2] = heightMap[ix, iy] - heightMap[ix + 1, iy - 1];
delHeight[3] = heightMap[ix, iy] - heightMap[ix - 1, iy];
delHeight[4] = heightMap[ix, iy] - heightMap[ix + 1, iy];
delHeight[5] = heightMap[ix, iy] - heightMap[ix - 1, iy + 1];
delHeight[6] = heightMap[ix, iy] - heightMap[ix, iy + 1];
delHeight[7] = heightMap[ix, iy] - heightMap[ix + 1, iy + 1];
v38[0] = new Vector3(-delHeight[0], delHeight[0], z - delHeight[0]);
v38[1] = new Vector3(0f, delHeight[1], z - delHeight[1]);
v38[2] = new Vector3(delHeight[2], delHeight[2], z - delHeight[2]);
v38[3] = new Vector3(-delHeight[3], 0f, z - delHeight[3]);
v38[4] = new Vector3(delHeight[4], 0f, z - delHeight[4]);
v38[5] = new Vector3(-delHeight[5], -delHeight[5], z - delHeight[5]);
v38[6] = new Vector3(0f, -delHeight[6], z - delHeight[6]);
v38[7] = new Vector3(delHeight[7], -delHeight[7], z - delHeight[7]);
normalMap[ix, iy] = Vector3.Zero;
for (int ii = 0; ii < 8; ii++) normalMap[ix, iy] += v38[ii] * vScale;
normalMap[ix, iy].Normalize();
}
}
// smooth
Vector3[] s = new Vector3[8];
int pas = 4;
for (int iS = 0; iS < pas; iS++)
{
for (int iy = 1; iy < outY - 2; iy++)
{
for (int ix = 1; ix < outY - 2; ix++)
{
if (normalMap[ix, iy] == Vector3.Backward) continue;
s[0] = normalMap[ix - 1, iy - 1];
s[1] = normalMap[ix, iy];
s[2] = normalMap[ix + 1, iy - 1];
s[3] = normalMap[ix - 1, iy];
s[4] = normalMap[ix + 1, iy];
s[5] = normalMap[ix - 1, iy + 1];
s[6] = normalMap[ix, iy + 1];
s[7] = normalMap[ix + 1, iy + 1];
normalMap[ix, iy] = Vector3.Zero;
for (int ii = 0; ii < s.Length; ii++)
normalMap[ix, iy] += s[ii];
normalMap[ix, iy].Normalize();
}
}
}
// color
int i = 0;
for (int iy = 0; iy < outY; iy++)
{
for (int ix = 0; ix < outX; ix++)
{
normalMap[ix, iy] *= new Vector3(16f, 16f, 1f);
normalMap[ix, iy].Normalize();
outColor[i] = new Color(new Color(normalMap[ix, iy] * 0.5f + vAddPack), heightMap[ix, iy]);
i++;
}
}
// texture
outTex.SetData(outColor);
outTex.Save(@"normalMap.tga", ImageFileFormat.Tga);
return outTex;
}

картинка normal map

результат Bump mapping'а

Calculation normal map for “Bump mapping” & “Parallax Mapping”

2009-06-15T17:58:00.000+04:00

Расчет normal map для“Bump mapping” и “Parallax Mapping”

Было время, когда разбирался с реализацией Bump и Parallax Mapping.
В статьях которые я находил, помнится очень раздражали высказывания типа:
"... Для расчета карт нормалей существуют специальные программы. На сайте nVidia для разработчиков есть плагин к PhotoShop'у. Все они действуют по одному и тому же принципу. В них задается карта высот, которая представляет собой черно-белое изображение, на котором более светлые пятна соответствует более высоким местам ..."(из оригинала).
Это не хорошо и не плохо. Просто нужна была конкретика.

Что нам может дать собственный расчет? Он избавит нас от необходимости включения в проект предварительно рассчитанных normal map текстур. И тем самым сократить размер дистрибутива. Так же во время расчета, проигравшись с коэффициентами, можно добиться различных результатов.

Потому, дабы сэкономить Вам время, привожу свой пример для XNA GS.

private Texture2D GenNormalMamp(Texture2D inTex)
{
int x = inTex.Width;
int y = inTex.Height;
int l = x * y;
Texture2D outTex = new Texture2D(graphics.GraphicsDevice, x, y);
Color[] color = new Color[l];
float[] height = new float[l];
inTex.GetData(color);
for (int i = 0; i < l; i++)
{
Vector3 v3 = color[i].ToVector3();
height[i] = (v3.X + v3.Y + v3.Z) / 3;
}
float[] delHeight = new float[8];
Vector3[] v38 = new Vector3[8];
for (int iy = 0; iy < y; iy++)
{
for (int ix = 0; ix < x; ix++)
{
if (iy == 0 || iy == y - 1 || ix == 0 || ix == x - 1)
{
color[iy * x + ix] = new Color(0.5f, 0.5f, 1f, 1f);
continue;
}
delHeight[0] = height[iy * x + ix] - height[(iy - 1) * x + ix - 1];
delHeight[1] = height[iy * x + ix] - height[(iy - 1) * x + ix ];
delHeight[2] = height[iy * x + ix] - height[(iy - 1) * x + ix + 1];
delHeight[3] = height[iy * x + ix] - height[iy * x + ix - 1];
delHeight[4] = height[iy * x + ix] - height[iy * x + ix + 1];
delHeight[5] = height[iy * x + ix] - height[(iy + 1) * x + ix - 1];
delHeight[6] = height[iy * x + ix] - height[(iy + 1) * x + ix ];
delHeight[7] = height[iy * x + ix] - height[(iy + 1) * x + ix + 1];
v38[0] = new Vector3(-delHeight[0], -delHeight[0], 1f);
v38[1] = new Vector3(0f, -delHeight[1], 1f);
v38[2] = new Vector3(delHeight[2], -delHeight[2], 1f);
v38[3] = new Vector3(-delHeight[3], 0f, 1f);
v38[4] = new Vector3(delHeight[4], 0f, 1f);
v38[5] = new Vector3(-delHeight[5], delHeight[5], 1f);
v38[6] = new Vector3(0f, delHeight[6], 1f);
v38[7] = new Vector3(delHeight[7], delHeight[7], 1f);
Vector3 vS = new Vector3();
for (int s = 0; s < 8; s++) vS += v38[s];
Vector3 v = vS;
v.X = v.X * 0.5f + 0.5f;
v.Y = v.Y * 0.5f + 0.5f;
color[iy * x + ix] = new Color(v);
}
}
outTex.SetData(color);
return outTex;
}

Берем стандартную текстуру из приложения к Microsoft DirectX SDK:

И получаем:

Если не поленюсь, чуть позже, приведу примеры реализации “Bump mapping” & “Parallax Mapping” в XNA.

Effect “Edge Detect”

2009-06-15T16:24:00.000+04:00

Последнее время, в форумах, часто упоминается данный эффект. И для тех, кто не знает решил рассказать и приложить рабочий пример на XNA.

Суть в следующем. Рендеринг выполняется в два прохода, потому для этого нам понадобятся два файла эффектов PositionNormal.fx и EdgeDetect.fx с различными техниками.

I. Как вы уже догадались первой техникой мы будем рисовать normal map.

Т.е. в эффекте PositionNormal.fx вместо цвета будем сохранять данные о нормали к данной точке. Но в следствии того, что каждый компонент цвета может хранить число из интервала {0, 1}, а нормали могут иметь отрицательные компоненты, то перед сохранением нормаль упакуем старым добрым способом:
Out.Normal = mul(normal, 0.5f) + 0.5f;

1) Очищаем экран в цвет Color(0.5f, 0.5f, 0f, 1f), на самом деле это не цвет а так же упокованная нормаль (0f, 0f, -1f, 1f).

2) Рисуем сцену первый раз при помощи PositionNormal.fx
(Текст эффекта)
float4x4 matWorld : WORLD;
float4x4 matWVP : WORLDVIEWPROJECTION;
struct VS_INPUT
{
float4 Position : POSITION0;
float3 Normal : NORMAL0;
};
struct VS_OUTPUT
{
float4 Position : POSITION0;
float3 Normal : COLOR0;
};
VS_OUTPUT vs_main( VS_INPUT In )
{
VS_OUTPUT Out = ( VS_OUTPUT ) 0;
Out.Position = mul( In.Position, matWVP );
float3 normal = normalize(mul(In.Normal, matWorld));
Out.Normal = mul(normal, 0.5f) + 0.5f;
return Out;
}
struct PS_INPUT
{
float3 Normal : COLOR0;
};

float4 ps_main(PS_INPUT In) : COLOR0
{
return float4(In.Normal, 1.0f);
}
technique PositionNormal
{
pass Pass_0
{
VertexShader = compile vs_3_0 vs_main();
PixelShader = compile ps_3_0 ps_main();
}
}
все просто, стоит только заострить внимание на двух строчках:
...
Out.Normal = mul(normal, 0.5f) + 0.5f;
...
return float4(In.Normal, 1.0f);
...

3) Нарисованную сцену сохраняем в текстуру

II. Анализируя полученную normal map, выводим контуры объектов сцены.

У меня есть несколько вариаций техник для этого эффекта.
Различаются они сложностью геометрии сцены и подходами сравнения нормалей соседних пикселей.
Своем пример я не стал усложнять и рассмотрел случай, когда фигура на сцене имеет гладкие грани (по всей плоскости грани, нормали имеют одинаковое значение).
Рисуем при помощи EdgeDetect.fx
(Текст эффекта)

float dx;
float dy;
texture ScreenTexture;
sampler ScreenS = sampler_state
{
Texture = ;
};
float4 PS(float2 texCoord: TEXCOORD0) : COLOR
{
float4 normal = tex2D(ScreenS, texCoord);
float4 normalLeft = tex2D(ScreenS, float2(texCoord.x - dx, texCoord.y));
float4 normalRight = tex2D(ScreenS, float2(texCoord.x + dx, texCoord.y));
float4 normalUp = tex2D(ScreenS, float2(texCoord.x, texCoord.y - dy));
float4 normalDown = tex2D(ScreenS, float2(texCoord.x, texCoord.y + dy));

float4 normalSum = mul(normalLeft + normalRight + normalUp + normalDown, 0.25f);

if(normal.x == normalSum.x && normal.y == normalSum.y && normal.z == normalSum.z)
return normal;
else
return float4(1.0f, 1.0f, 1.0f ,1.0f); // цвет контура
}
technique EdgeDetect
{
pass P0
{
PixelShader = compile ps_3_0 PS();
}
}

где:
dx, dy - задают толщину линии контура.

В этом примере я не стал распаковывать сравниваемые нормали normal и normalSum.
Тут этого не требовалось, и мы не будем перегружать пиксельный шейдер.
Распаковка типа:
normal = (normal - 0.5f) * 2.0f;
Может потребоваться тогда, когда Вам нужно будет анализировать normal map с отображенными объектами, поверхности которых изогнуты.

В примере кроме контура объекта выводятся цветные грани, не пугайтесь, это для наглядности я отобразил нормали.

Скачать пример можно тут (для скачивания требуется регистрация на xnadev.ru).

На реализацию эффекта вдохновило демо, группы ASD.

КРИ 2009 послесловие

2009-05-21T00:12:00.000+04:00

Альтернативное название статьи: «Как мы стали КРИшнаитами»

Началось с того, что называется «попали с корабля на бал». Только с самолета, забросили в номер вещи и спустились в зал выставки.

Мы не ставили высокий приоритет задаче посещения докладов, тем более, что знали – будет снимать «первый игровой»! Стало быть, позже можно будет скачать и комфортно посмотреть дома. Потому некоторое время осматривались, а после пошли знакомиться и общаться с представителями компаний и проектов, представленных в павильоне выставочного комплекса. Не особенно много времени уделяя издателям, процесс растянулся на все три дня.

Первое серьезное общение произошло с Intel’ом. Очень заинтересовал представленный ими «Graphics Performance Analyzers». Нам были продемонстрированы основные функциональные возможности и режимы анализа. Поговорили о сравнении с похожей DirectX утилитой PIX. Скажу так, я бы очень хотел понаблюдать за соревнованием «GPA против PIX», если таковое случится, и в итоге воспользоваться наилучшим результатом!
Так же поговорили про ежегодные конкурсы проводимые Intel’ом. Признаться я о многом читал ранее, но был уверен, что конкурсы ориентированы либо на графическое железо Intel (видео), либо на то, что приложения должны быть написаны исключительно на С++. Это оказалось не так, ни каких ограничений, NET Framework только приветствуется. Жаль то, что недавно отменили денежные вознаграждения. Но если не забыли – это же Intel. А это означает, что ни кто не отменял много вкусных железяк, вперемешку с кремниевыми пластинами! Так же мне более подробно рассказали про систему оценки специалистов, аналог Microsoft MVP, заключающуюся в присвоении цветных поясов означающих степень умений. Все это очень интересно, в ближайшее время почитаю их сайт.
По ходу разговора Intel’ы, нас щедро просто завалили подарками. Особенно порадовали бубны:

Просто мега зачет!

Далее прошлись по выставке проектов. Общения было много. На самом деле интересного оказалось гораздо меньше. Неплохо выглядели несколько онлайновых разработок. Это «EARTH2» и «Graft of Gods». Если ребятам хватит сил довести проекты до конца и выдержать акцент оригинальности то «линейка» и ей подобные погибнут.

Особое внимание хочу обратить внимание на продукт «Folio verso» творческого объединения «SINE CAUSA». Это просто нечто. Нет тут не идет разговор о навороченном 3d и шейдерных спецэффектах. Ребята просто выступали в отдельной весовой категории и соревноваться им было не с кем, по причине отсутствия аналогов.
Поясню, ребята профессиональные фотографы. И судя по их работе, фотографы от бога. Но так как мы говорим о фотографии, это не означает, что в игре нам предлагается статичная картинка. Вовсе нет. Только во время короткой демонстрации я насчитал пять оригинальный фишек-находок, которые очень порадовали глаз, удивили и заинтриговали. У меня, как и у любого другого человека было сложившееся мнение о фотографах и их возможностях, но эти ребята просто порвали стереотипы. И отличились именно в игровом жанре.
Жанр игры можно зауши притянуть к детективному. Почему за уши? Потому что я не знаю, как точно такой жанр называется. Так же имеется интригующий запутанный сюжет, ряд интересных персонажей, глубокая психологическая и скорее всего ближе к развязке сюжета философская подоплека.

Далее познакомились, разговорились и нашли много общего с ребятами из «Kraken Games».

Общего потому, что представленный проект - платформер «WARSIDE», реализован на C++OpenGL. Как ни как в рамках этих технологий прошло мое детство. И хоть я уже ни когда не вернусь к ним, всегда есть что вспомнить. Потому было о чем поговорить, посмеяться над характерными данным технологиям сложностями. В разговоре оказалось, что в их команде есть C# кодер, что еще больше оживило беседу. Подняли вопрос о логике работы «сборщика мусора» общеязыковой среды CLR и о том как строить приложения эффективно использующие память.

До самых больших проектов, дабы как и со всеми обстоятельно пообщаться, смогли пробиться только на третий день.
«U-WARS» компания «BIART STUDIO» - очень зрелищный action. «Gears of War» уходит на пенсию. Буду ждать первых бенчмарков. Как раз будет повод погонять свой gf280. Демонстрация показанная на большом экране понравилась.

И на последок я оставил «Зов Припяти» от «GSC GAME WORLD».

С этими ребятами мы общались дольше всех. В первую очередь обсудили изменения в плане построения развития сюжета и расположения ключевых точек в локациях, механизма изнашивания и заклинивания оружия. Так же нам рассказали массу интересных и веселых моментов возникавших при отладке ИИ со времен первой части. Но как оказалось мало кто знает, и мы тоже, что уже не однократно по Украине и России проводились военизированные игры по сталкерской тематике. Ели говорить коротко, то один из полигонов имел площадь 60 кв.км, у военных арендовали БТР’ы, присутствовали все виды нечисти и все группировки. Больше информации вы найдете на тематических сайтах. Я же в ближайшее время планирую поискать видео. От себя хочу заметить – люди всех возрастов объединенные сталкерством отдыхать умеют! Что не могу сказать о себе. Видимо нужно брать пример и учиться.

Как наверно и всегда было много ярких девушек:

На последок расскажу о своем докладе. Скажу честно собой не доволен. Волновался чуть больше чем того стоило. Конкретно не вложился по времени cо своим обзором инструментария XNA GS 3.0 в свои 20 минут, да и сложно было сказать в таких условиях больше. И как в последствии сказал Евгений Марченков: «Дим, если бы я тебя не остановил, ты расска;зывал бы и час». И меня не оправдывает то, что на протяжении последних лет больше всего времени я уделяю общению с интерфейсом Visual Studio. Работать есть над чем.

КРИ 2009

2009-05-14T17:45:00.000+04:00

КРИ - Конференция Разработчиков компьютерных Игр пройдет с 15 по 17 мая.
подробности: kriconf.ru

Все выступления КРИ-2009 будут записываться телеканалом«Первый Игровой» (Gameplay TV) и позже будут доступны на официальном сайте конференции в стандартном и высоком разрешениях.
подробности: dtf.ru

От себя добавлю, буду выступать во второй день, доклад в котором я приму участие называется -
"Практика разработки игр на XNA Game Studio 3.0 под PC и XBOX 360".

Поясню несколько опорных моментов, по поводу того, что впоследствии будет мною сказано:
- Во первых, все мои слова будут отражать характер моей, индивидуальной точки зрения. Описывать мое личное отношение к XNA, мои мысли.
- Во вторых не стоит питать иллюзий по поводу того, что я каким то волшебным образом за столь короткий отведенных промежуток времени смогу описать всю техническую картину, реализованную в XNA GS и соответственно прокомментировать с точки зрения своего опыта.

С удовольствием отвечу на возникшие впоследствии вопросы в рамках тематического ресурса XNAdev.ru