forum.boolean.name - Написал c# враппер

forum.boolean.name (http://forum.boolean.name/index.php)

- Xors3D (http://forum.boolean.name/forumdisplay.php?f=126)

- - Написал c# враппер (http://forum.boolean.name/showthread.php?t=15832)

Ответ: Написал c# враппер

Да вроде матрицы, может еще чего

Ответ: Написал c# враппер

Обновлено 15.11.2011 13:10
Изменена структура (спасибо pax)
Добавлена структура enum KeyCodes
Добавлены статические D3DXMATRIX - типы
Изменена функция SetEffectMatrix, в качестве value она принимает D3DXMATRIX
Улучшена организация памяти, добавлены hashTables для наиболее распространенных типов объектов Entity, Surface, Brush, Texture, World
По всем косякам обращаться ко мне =). Кстати там непонятка, например D3DXMATRIX EntityMatrix тоже тип d3dxmatrix который хранит в себе хэндл.. следовательно я матрицу из энтити могу запихнуть в SetEffectMatrix, это правильно?

Ответ: Написал c# враппер

Наработал небольшой редактор, альфа версия, для моего враппера
Посмотрите на моем сайте

Vector3 может сохранять вершину в ToString()
Entity имеет функцию State.GetPath() это его путь включая всех родителей
Entity имеет функцию State.GetChildFromPath - получить потомка из указанного пути

Люди. Кто знает если в максе создать анимированную модель на сцене, загрузить эту сцену with childs, найти анимационный entity. Будет ли он играть анимацию?

Ответ: Написал c# враппер

Я бы сделал вот такую реализацию Vector3:

PHP код:


		
			
using System;

namespace Xors
{
    public struct Vector3
    {
        public float X;
        public float Y;
        public float Z;

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

        public override string ToString()
        {
            //return X + ";" + Y + ";" + Z + ";";
            return String.Format("{0:0.00};{1:0.00};{2:0.00}", X, Y, Z);
        }


        // возвращает нормализованный вектор
        public Vector3 normalized
        {
            get
            {
                return Vector3.Normalize(this);
            }
        }

        // возвращает длину вектора
        public float magnitude
        {
            get
            {
                return (float)Math.Sqrt(X * X + Y * Y + Z * Z);
            }
        }

        // возвращает длину вектора в квадрате
        public float sqrMagnitude
        {
            get
            {
                return X * X + Y * Y + Z * Z;
            }
        }

        // возвращает нулевой вектор
        public static Vector3 zero
        {
            get
            {
                return new Vector3(0f, 0f, 0f);
            }
        }

        // возвращает единичный вектор
        public static Vector3 one
        {
            get
            {
                return new Vector3(1f, 1f, 1f);
            }
        }

        public static Vector3 forward
        {
            get
            {
                return new Vector3(0f, 0f, 1f);
            }
        }

        public static Vector3 back
        {
            get
            {
                return new Vector3(0f, 0f, -1f);
            }
        }

        public static Vector3 up
        {
            get
            {
                return new Vector3(0f, 1f, 0f);
            }
        }

        public static Vector3 down
        {
            get
            {
                return new Vector3(0f, -1f, 0f);
            }
        }
        public static Vector3 left
        {
            get
            {
                return new Vector3(-1f, 0f, 0f);
            }
        }

        public static Vector3 right
        {
            get
            {
                return new Vector3(1f, 0f, 0f);
            }
        }

        // оператор сложения векторов
        public static Vector3 operator +(Vector3 one, Vector3 other)
        {
            return new Vector3(one.X + other.X, one.Y + other.Y, one.Z + other.Z);
        }

        // унарный оператор отрицания
        public static Vector3 operator -(Vector3 v)
        {
            return new Vector3(-v.X, -v.Y, -v.Z);
        }

        // оператор вычитания
        public static Vector3 operator -(Vector3 one, Vector3 other)
        {
            return new Vector3(one.X - other.X, one.Y - other.Y, one.Z - other.Z);
        }

        // оператор умножения вектора на число
        public static Vector3 operator *(Vector3 a, float d)
        {
            return new Vector3(a.X * d, a.Y * d, a.Z * d);
        }

        // оператор умножения вектора на число
        public static Vector3 operator *(float d, Vector3 a)
        {
            return new Vector3(a.X * d, a.Y * d, a.Z * d);
        }

        // оператор деления вектора на число
        public static Vector3 operator /(Vector3 a, float d)
        {
            return new Vector3(a.X / d, a.Y / d, a.Z / d);
        }

        // оператор равенства векторов
        public static bool operator ==(Vector3 lhs, Vector3 rhs)
        {
            return SqrMagnitude(lhs - rhs) < 1E-9f;
        }

        // оператор неравенства векторов
        public static bool operator !=(Vector3 lhs, Vector3 rhs)
        {
            return SqrMagnitude(lhs - rhs) >= 1E-9f;
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode() << 2 ^ Z.GetHashCode() >> 2;
        }

        public override bool Equals(object other)
        {
            if (!(other is Vector3))
            {
                return false;
            }
            return this == (Vector3)other;
        }

        // функция нормализации вектора
        public static Vector3 Normalize(Vector3 value)
        {
            float num = Magnitude(value);
            if (num > 1E-05f)
            {
                return value / num;
            }
            return zero;
        }

        // функция нормализации текущего вектора
        public void Normalize()
        {
            float num = Magnitude(this);
            if (num > 1E-05f)
            {
                this /= num;
            }
            else
            {
                this = zero;
            }
        }

        // функция расчета расстояния между точками
        public static float Distance(Vector3 a, Vector3 b)
        {
            var vector = new Vector3(a.X - b.X, a.Y - b.Y, a.Z - b.Z);
            return (float)Math.Sqrt(vector.X * vector.X + vector.Y * vector.Y + vector.Z * vector.Z);
        }

        // функция расчета длины вектора
        public static float Magnitude(Vector3 a)
        {
            return (float)Math.Sqrt(a.X * a.X + a.Y * a.Y + a.Z * a.Z);
        }

        // функция расчета длины вектора в квадрате
        public static float SqrMagnitude(Vector3 a)
        {
            return a.X * a.X + a.Y * a.Y + a.Z * a.Z;
        }

        // линейная интерполяция векторов
        public static Vector3 Lerp(Vector3 from, Vector3 to, float t)
        {
            t = t > 1 ? 1 : t;
            t = t < 0 ? 0 : t;
            return new Vector3(from.X + (to.X - from.X) * t, from.Y + (to.Y - from.Y) * t, from.Z + (to.Z - from.Z) * t);
        }

        // масштабирование текущего вектора значениями другого вектора
        public void Scale(Vector3 scale)
        {
            X *= scale.X;
            Y *= scale.Y;
            Z *= scale.Z;
        }

        // векторное произведение векторов
        public static Vector3 Cross(Vector3 lhs, Vector3 rhs)
        {
            return new Vector3(lhs.Y * rhs.Z - lhs.Z * rhs.Y, lhs.Z * rhs.X - lhs.X * rhs.Z, lhs.X * rhs.Y - lhs.Y * rhs.X);
        }

        // функция вычисляет вектор отражения
        public static Vector3 Reflect(Vector3 inDirection, Vector3 inNormal)
        {
            return -2f * Dot(inNormal, inDirection) * inNormal + inDirection;
        }

        // скалярное произведение векторов
        public static float Dot(Vector3 lhs, Vector3 rhs)
        {
            return lhs.X * rhs.X + lhs.Y * rhs.Y + lhs.Z * rhs.Z;
        }

        // угол между векторами
        public static float Angle(Vector3 from, Vector3 to)
        {
            var dot = Dot(from.normalized, to.normalized);
            dot = dot < -1 ? -1 : dot;
            dot = dot > 1 ? 1 : dot;
            return (float)Math.Acos(dot) * 57.29578f;
        }

        // возвращает вектор с минимальными значениями каждой составляющей двух векторов
        public static Vector3 Min(Vector3 lhs, Vector3 rhs)
        {
            return new Vector3(Math.Min(lhs.X, rhs.X), Math.Min(lhs.Y, rhs.Y), Math.Min(lhs.Z, rhs.Z));
        }

        // возвращает вектор с максимальными значениями каждой составляющей двух векторов
        public static Vector3 Max(Vector3 lhs, Vector3 rhs)
        {
            return new Vector3(Math.Max(lhs.X, rhs.X), Math.Max(lhs.Y, rhs.Y), Math.Max(lhs.Z, rhs.Z));
        }

        public bool Equals(Vector3 other)
        {
            return this == other;
        }


    }
}

Ответ: Написал c# враппер

Половину математических функций я не понял, но все равно да будет так )))
Блин не получается запилить deferred shading. Без этого шейдера, вся графика отстает на 10 лет

Ответ: Написал c# враппер

я бы Equals сделал лучше так:

Цитата:

public bool Equals(Vector3 other)
{
return (other-this).sqrmagnitude < eps;
}

, хотя возможно в Equals для float-а уже предусмотрели проблему с погрешностью флоата.

Ответ: Написал c# враппер

Цитата:

Сообщение от HolyDel (Сообщение 210073)

хотя возможно в Equals для float-а уже предусмотрели проблему с погрешностью флоата.

Не не предусмотрели, я что-то тоже проморгал. Скопировал этот метод из декомпилированного Vector3 из UnityEngine.dll

Просто раньше я видел этот метод и он был примерно таким, как ты написал.

UPD: Поправил.

Ответ: Написал c# враппер

Большинство из названий скопированы из декомпилированного класса Vector3 из UnityEngine.dll, собственно от сюда и имена такие.

PS: И это не класс, это структура. Т.к. с векторами придется работать часто, то они должны уничтожаться сразу после выхода из области видимости, а не ждать сборщика.

UPD: добавил несколько комментариев в код класса

Ответ: Написал c# враппер

MoKa внеси свой вклад.. замути deferred shading :-D а я сейчас паралаксом занимаюсь для 1 источника света... надеюсь получится

Ответ: Написал c# враппер

готов параллакс

Mesh cube = Mesh.CreateCube();
cube.Control.SetTexture("Rockwall_Diffuse.jpg", 0, 0);
cube.Control.SetTexture("Rockwall_normal.jpg", 0, 1);
cube.Control.SetTexture("Rockwall_Displace.jpg", 0, 2);
cube.ShaderEffect.SetParallax(camera, "parallax.fx");

во вложении шейдер

Ответ: Написал c# враппер

А дисплейс не лучше в альфе нормалмэпы хранить?

Ответ: Написал c# враппер

Цитата:

Сообщение от pax (Сообщение 210112)

А дисплейс не лучше в альфе нормалмэпы хранить?

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

Ответ: Написал c# враппер

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

Ответ: Написал c# враппер

Кручение камеры (Rotate) никак не должно влиять на смещение для параллакса. Только позиция влияет на это, т.к. ты ведь определяешь перспективу с точки зрения до пикселя, и тут поворот камеры не важен.
Насчёт освещения, тут всё просто - то же самое, только вычислять его нада после уже смещений, т.к. смещать нужно как diffuse так и normal карты.

Вот делал давно, шейдер не очень оптимизирован, и стиль совсем убогий был: http://moka.ucoz.ru/load/0-0-0-84-20