verwendetes Datenbanksystem: Oracle 10g (XE für Windows) via NHibernate

Hallo,

wenn ich versuche ein Objekt aus der Datenbank zu lesen und es anschließend in eine andere Datenbank schreiben möchte, erhalte ich folgenden Fehler:

"a different object with the same identifier value was already ass
ociated with the session: 0, of entity: <Class>"

Folgendes habe ich getan:

NHibernateSession session = new NHibernateSession(sourceDb);
IList<DBObject> dbObjects = session.Objects; //Entspricht session.CreateCriteria<DBObject>().List<DBObject>();
session.Dispose();

NHibernateSession session2 = new NHibernateSession(destDb);
session2.SaveOrUpdate(new DBObject());
session2.Dispose();

Der Code ist gegenüber dem oreginal stark vereinfacht. Die Session beinhaltet das Erstellen der NHibernate-Config sowie das Erstellen der Session. Der Code stellt auch einen Test dar, deswegen erzeuge ich hier das Objekt neu. Dennoch erhalte ich immer diesen Fehler, obwohl ich das Objekt neu erzeuge und es nichts mit der ersten session zu tun hat.

So sieht das Dispose aus:

if (session.Transaction != null && session.Transaction.IsActive)
                session.Transaction.Rollback();

            session.Flush();
            session.Clear();
            session.Close();
            session.Dispose();
            session = null;

            sessionFactory.Dispose();
            sessionFactory = null;

Session ist hierbei die NHibernate ISession.

Kann mir jemand helfen?

cl muss A<string> für new B() und A<int> für new C() sein.

Ähm... Aus dem Kontext, so dachte ich zumindest, wäre erkennbar gewesen, dass es nicht anders geht, da ich im Zweifel nicht weiß, welches konkrete Objekt gesetzt wird.

Wegen der Covarianz: Das ist irgendwie komisch, in Java geht es doch auch! Außerdem geht durch diese Einschränkung ein wesentlicher Teil der OOP (die Vererbung) verloren. Dann würde ich unter diesen Gesichtspunkten die Nutzbarkeit und die Sinnhaftigkeit von Generics in C# auf Klassen angewendet erheblich in Frage stellen, da, wie gesagt, die OOP nicht mehr richtig funktioniert.

OK, aber Danke für die Antworten.

Hallo,

wie kann ich eine konkrete Implementierung einer Klasse auf die Basis-Klasse setzen, wenn diese einen generischen Typen besitzt?

Folgendes Beispiel macht Probleme:

public abstract class A<T>
{
}

public sealed class B : A<String>
{
}

public sealed class C : A<Int32>
{
}

...

A<Object> cl = null;
if (foo)
{
   cl = new B(); //Compiler error
} 
else
{
   cl = new C(); //Compiler Error
}

Wie kriege ich das hin?

Hi,

also, zu Punkt 1:
Das geht nicht, da die Auflösung durch das aktive Spiel selbst (Direct3D) geändert werden muss. Dies ist bei diesem Spiel allerdings nur vor dem eigentlichen Spielstart möglich.

Zu Punkt 2:
Ja, es tritt merklich bei allen 3D-Vision-Ready-Spielen auf, wobei Skyrim kein 3D-Vision-Ready Spiel ist, aber z. B. auch bei The Witcher 2. Darüber hinaus ist mir das bis jetzt bei anderen Spielen noch nicht weiter aufgefallen.

Hallo,

ich habe eine NVidia GeForce FTX 570 Grafikkarte. Wenn ich das Spiel "Skyrim" im Normalmodus starte, wird die Szenerie in ca. 10 Sekunden geladen. Dabei erscheint der Ladebildschirm. Wenn ich allerdings den NVidia-3D-Vision-Modus einschalte und das Spiel starte, dann eine Szenerie lade, dauert dies bis zu 2 Minuten. Der Ladebildschirm wird entsprechend auch mit angezeigt.

Woran liegt das?

Da ich die gleiche Szenerie lade, fallen ja für den Ladevorgang im 3D-Modus nicht mehr Daten an als im 2D-Modus. Das Rendering ist dann flüssig.

Danke.

Vielen, vielen Dank, ich werde es mir gleich ansehen. Genau das habe ich gesucht.

Komisch, wenn ich nur 3D angegeben habe, war damit meist nicht Stereoskopisch gemeint, sondern nur 3D halt.

Danke!

Hallo,

danke für deine Antwort.

Das ist mir schon klar, allerdings möchte ich zuvor feststellen, ob meine Grafikkarte dazu überhaupt in der Lage ist. Die Geräte sind ja nun auch nicht gerade billig.

Hallo,

ich habe da mal eine Frage:
Ich habe eine Radeon HD 4870 Grafikkarte mit dem neuesten Treiber. Ich habe jetzt schon seit Stunden das Internet durchforstet, um herauszufinden, ob es dank der neuen Treiber von ATI möglich ist, auch solche "alten" Grafikkarten zum 3D (Stereoskopie) Spielen zu verwenden.

Kann mir da jemand weiterhelfen und berichten, ob das wirklich möglich ist?

Ich habe die AMD Catalyst™ 11.2 Release Notes gefunden.

Danke.

Hi,

wie sieht denn das ganze bitte unter Windows 7 aus? Da gibt es ja keine cards.dll mehr. Was kann ich da verwenden?

Hallo,

habe den Fehler gefunden.

Es liegt daran, dass die Thumbnail-Buttons erst hinzugefügt werden dürfen, wenn das Ereignis AddButtons auftritt, das man über die WndProc Methode abfangen kann:

protected override void WndProc(ref Message m)
        {
            if (m.Msg == COMConstants.COMCommands.WmTaskbarButtonCreated)
            {
                Log.Debug("Create thumb buttons");
                buttonManager.AddButtonsToTaskbar();
            }

            buttonManager.HandleEvents(ref m);

            base.WndProc(ref m);
        }

[DllImport("user32.dll", EntryPoint = "RegisterWindowMessage", SetLastError = true, CharSet = CharSet.Unicode)]
        private static extern uint RegisterWindowMessage([MarshalAs(UnmanagedType.LPWStr)] string lpString);
private static readonly uint wmTaskbarButtonCreated = RegisterWindowMessage("TaskbarButtonCreated");
            public static uint WmTaskbarButtonCreated { get { return wmTaskbarButtonCreated; } }

Das ist zwar alles schön und gut, aber erlich gesagt habe ich mittlerweile keine Lust mehr, mich bei noch mehr Foren anzumelden, damit ich da einmal im Leben eine Frage stellen kann. Wie groß soll den mein "digitaler Schatten" noch werden?

Nun ja, das ganze soll Bestandteil einer Tools-Sammlung werden. Da möchte ich möglichst auf externe DLLs verzichten.

Hat wirklich keiner eine Ahnung, woran es liegen könnte?

Hallo,

ich habe da mal eine Frage: Es gibt z. Z. zwei größere Hersteller von Eisenbahnsimulationen, Pro Train Professional (2) und Train Simulator Railworks. Ich habe mal nach den allgemeinen Meinungen recherchiert, dabei ergab sich, dass beide Spiele mehr oder weniger gleich gut oder schlecht bewertet wurden. Kann mir jemand seine Meinung dazu schreiben oder vielleicht sogar selber einen eigenen Tip abgeben?

Mir kommt es vor allem darauf an:

• Bugfreiheit
• Kompatibilität auch für zukünftige Systeme (z. B. Windows 8, DirectX12 GraKas, usw.)
• Viele AddOns mit neuen Rollmaterial und großen Strecken (auch in Zukunft steigend)
• Gute Grafik mit belebter Umgebung

Mein Zielsystem:

• AMD 4-Kern-Prozessor mit je 2,21 GHz (AMD 64 3400+)
• 8 GB Arbeitsspeicher
• Radeon HD 4870 (2x mit Crossfire verbunden)
• Windows 7 64-Bit

OK, dann vielen Dank.

Hallo,

ich habe ein Problem bei der Verwendung der ThumbnailButtons der neuen Windows 7 Taskleiste.

Ich habe folgenden Code und das Standard-ITaskbarList3-Interface (von hier).

public sealed class Windows7TaskBarTools
    {
        #region Static

        private static Windows7TaskBarTools tools = null;

        public static String LastError { get; private set; }

        public static Windows7TaskBarTools Instance
        {
            get
            {
                if (tools == null)
                {
                    try
                    {
                        //Default windows 7 taskbar tools
                        tools = new Windows7TaskBarTools(true);
                    }
                    catch (Exception e)
                    {
                        LastError = e.Message;
                        //Emergency windows 7 taskbar tools (do nothing)
                        tools = new Windows7TaskBarTools(false);
                    }
                }

                return tools;
            }
        }

        #endregion

        private ITaskbarList3 taskbar = null;
            
        private Windows7TaskBarTools(bool create)
        {
            if (create)
                taskbar = (ITaskbarList3)new TaskbarList();
        }

        public bool IsUsed
        {
            get { return taskbar != null; }
        }

        public void SetTaskbarProgress(IntPtr hwnd, ulong value, ulong max)
        {
            if (IsUsed)
                taskbar.SetProgressValue(hwnd, value, max);
        }

        public void SetTaskbarProgressStyle(IntPtr hwnd, TaskbarProgressStyle style)
        {
            if (IsUsed)
            {
                //int tmp = (int)style;
                taskbar.SetProgressState(hwnd, (TBPFLAG)style);
            }
        }

        public void SetOverlayIcon(IntPtr hwnd, Icon icon, string description)
        {
            if (IsUsed)
                taskbar.SetOverlayIcon(hwnd, icon.Handle, description);
        }

        public void SetOverlayIcon(IntPtr hwnd, Bitmap icon, string description)
        {
            if (IsUsed)
                taskbar.SetOverlayIcon(hwnd, icon.GetHicon(), description);
        }

        public void SetThumbnailClip(IntPtr hwnd, int x, int y, int width, int height)
        {
            if (IsUsed)
            {
                RECT r = new Rectangle(x, y, width, height);
                taskbar.SetThumbnailClip(hwnd, ref r);
            }
        }

        public void SetThumbnailToolTip(IntPtr hwnd, String tip)
        {
            if (IsUsed)
                taskbar.SetThumbnailTooltip(hwnd, tip);
        }

        public void UpdateThumbnailButtons(IntPtr hwnd, params ThumbnailButton[] buttons)
        {
            if (IsUsed)
            {
                List<THUMBBUTTON> comButtons = new List<THUMBBUTTON>();
                foreach (ThumbnailButton button in buttons)
                {
                    comButtons.Add(button);
                }

                HRESULT result = taskbar.ThumbBarUpdateButtons(hwnd, (uint)buttons.Length, comButtons.ToArray());
                if (result != HRESULT.S_OK)
                {
                    throw new COMException("Cannot update thumb button: " + result.ToString());
                }
            }
        }

        public void AddThumbnailButtons(IntPtr hwnd, params ThumbnailButton[] buttons)
        {
            if (IsUsed)
            {
                List<THUMBBUTTON> comButtons = new List<THUMBBUTTON>();
                foreach (ThumbnailButton button in buttons)
                {
                    comButtons.Add(button);
                }

                HRESULT result = taskbar.ThumbBarAddButtons(hwnd, (uint)buttons.Length, comButtons.ToArray());
                if (result != HRESULT.S_OK)
                {
                    throw new COMException("Cannot add thumb button: " + result.ToString()); 
                }
            }
        }
    }

public class ThumbnailButton : IDisposable
    {
        #region Static

        private static IList<uint> idList = new List<uint>();

        private static uint CreateID()
        {
            Random rand = new Random();

            uint id = (uint)rand.Next();
            while (idList.Contains(id))
                id = (uint)rand.Next();

            return id;
        }

        private static void DeleteID(uint id)
        {
            idList.Remove(id);
        }

        #endregion

        private THBMASK type;
        private THBFLAGS state;
        public uint ID { get; set; }
        private Icon icon;
        public String ToolTip { get; set; }
        public IntPtr Parent { get; private set; }

        public event EventHandler Click;
        public event EventHandler Updated;

        public bool IsEnabled
        {
            get { return (state & THBFLAGS.THBF_ENABLED) != 0; }
            set
            {
                if (value == IsEnabled)
                    return;

                if (value)
                {
                    state = state | THBFLAGS.THBF_ENABLED;
                    state = state ^ THBFLAGS.THBF_DISABLED;
                }
                else
                {
                    state = state ^ THBFLAGS.THBF_ENABLED;
                    state = state | THBFLAGS.THBF_DISABLED;
                }

                OnUpdate();
            }
        }

        public bool HasBackground
        {
            get { return (state & THBFLAGS.THBF_NOBACKGROUND) == 0; }
            set
            {
                if (value == HasBackground)
                    return;

                if (value)
                    state = state ^ THBFLAGS.THBF_NOBACKGROUND;
                else
                    state = state | THBFLAGS.THBF_NOBACKGROUND;

                OnUpdate();
            }
        }

        public bool IsVisible
        {
            get { return (state & THBFLAGS.THBF_HIDDEN) == 0; }
            set
            {
                if (value == IsVisible)
                    return;

                if (value)
                    state = state ^ THBFLAGS.THBF_HIDDEN;
                else
                    state = state | THBFLAGS.THBF_HIDDEN;

                OnUpdate();
            }
        }

        public bool IsDismissionClick
        {
            get { return (state & THBFLAGS.THBF_DISMISSONCLICK) != 0; }
            set
            {
                if (value == IsDismissionClick)
                    return;

                if (value)
                    state = state | THBFLAGS.THBF_DISMISSONCLICK;
                else
                    state = state ^ THBFLAGS.THBF_DISMISSONCLICK;

                OnUpdate();
            }
        }

        public Icon Icon
        {
            get { return icon; }
            set
            {
                icon = value;
                OnUpdate();
            }
        }

        private bool isInitialized = false;

        public ThumbnailButton(IntPtr parent, String tooltip, Icon icon)
        {
            this.ID = CreateID();
            this.ToolTip = tooltip;
            this.state = THBFLAGS.THBF_ENABLED;

            this.icon = icon;
            this.type = THBMASK.THB_ICON | THBMASK.THB_TOOLTIP | THBMASK.THB_FLAGS;

            this.Parent = parent;

            this.isInitialized = true;

            Windows7TaskBarTools.Instance.AddThumbnailButtons(this.Parent, this);
            Windows7TaskBarTools.Instance.UpdateThumbnailButtons(this.Parent, this);
        }

        public static implicit operator THUMBBUTTON(ThumbnailButton tb)
        {
            THUMBBUTTON res = new THUMBBUTTON();
            res.dwFlags = tb.state;
            res.dwMask = tb.type;
            res.hIcon = tb.icon.Handle;
            res.iBitmap = 0;
            res.iId = tb.ID;
            res.szTip = tb.ToolTip;

            return res;
        }

        public void WndProcCall(ref Message msg)
        {
            switch (msg.Msg)
            {
                case 0x0111:
                    if ((uint)(msg.WParam.ToInt32() & 0xFFFF) == this.ID)
                        if (Click != null)
                            Click(this, new EventArgs());
                    break;
            }
        }

        protected virtual void OnUpdate()
        {
            if (!isInitialized)
                return;

            if (Updated != null)
                Updated(this, new EventArgs());

            Windows7TaskBarTools.Instance.UpdateThumbnailButtons(this.Parent, this);
        }

        #region IDisposable Member

        public void Dispose()
        {
            
        }

        #endregion
    }

Das Problem: Kein Fehler, dennoch kein Button, der erscheint. Es soll dazu ausschließlich der Aufruf des ThumbnailButton-Constructors ausreichen.

Hier der Aufruf im Konstruktor in einer Windows Forms:

ThumbnailButton btn = new ThumbnailButton(this.Handle, "Bla Blub",
                Resources.File001);

Habe ich was bei der implicit-umwandlung was falsch gemacht? Oder habe ich was beim Aufruf falsch gemacht?

PS: Dass das Ganze wirklich aufgerufen wird, habe ich bereits geprüft durch Debugging.

Danke.

Nun ja, bei Ogre ist das Hauptproblem: Ohne die Shader unter "media" sieht es genauso "Scheiße" aus, wie sonst auch alles andere. Zudem ist die Ansteuerung der Scripte furchtbar komplex. Man muss sich daher schon viel von den Beispielen klauen, um überhaupt etwas zu erreichen. Und, bei Ogre ist, im gegensatz zu Irrlicht, z. B. die Verwendung von Paralaxing nicht Standard. Ich kenne auch keine Scripte innerhalb der Beispiele dafür. Das fand ich natürlich bei Irrlicht schon interessant. Zudem gibt es weder Kollision noch Klang Systeme, insbesondere nicht für C#.

Noch etwas: Die Leadwerks Engine habe ich mir angesehen, sie gefällt mir, jedoch: Ich kann nur etwas nicht aus dem (fernen) Ausland stammendes kaufen.

Hallo,

ich möchte nun endlich mal Spiele mit ordentlicher Grafik auf einfachem Wege entwickeln. Das Problem: Die Engine. Welche sollte ich nehmen? Beide haben Vor- und Nachteile.

Ogre - PRO

• einfachste Materialdefinition durch Scripte
• Sehr gute Wassereffekte

Ogre - CONTRA

• Sehr komplizierte Shader-Einbindung
• Keine (komplexe) GUI
• Kein Sound, keine Kollisionserkennung
• Keine offiziellen Tools

Irrlicht - PRO

• sehr einfache und kurze Programmierung
• viele Standards sind enthalten (Paralax Effect, Shadowmapping)
• Offizielle Tools (z. B. Szeneneditor)
• Unterstützung vieler Meshes

Irrlicht CONTRA

• Wassereffekte sind so "lala"
• Möglicherweise falsche Schattendarstellung
• Kein Compositor vorhanden (Gesamtbild verändern)

Oder gibt es sogar noch andere Engines, die ihr mir empfehlen könntet? Interessieren würde mich auch mal, ob es Engines gibt im Rahmen von 100 bis 200€, die man z. B. bei Amazon kaufen könnte, mit denen man auch sehr gute Effekte erzielen kann. Allerdings sollten die Standard-Effekte wie Wasser, Schatten, Paralaxing usw. enthalten sein und sie muss eine gute Beschreibung haben.

OK, danke.

Es ist leider etwas schwieriger bei mir: Ich habe eine BitmapSource und möchte auf diesen einen Effect anwenden, den ich dann in eine neue BitmapSource speichere:

public static BitmapSource UseEffect(this BitmapSource source, Effect effect)
        {
            RenderTargetBitmap bmp = new RenderTargetBitmap((int)source.Width, 
                (int)source.Height, Math.Round(source.DpiX), Math.Round(source.DpiY), 
                PixelFormats.Pbgra32);
            Border image = new Border();
            image.RenderSize = new Size(source.Width, source.Height);
            image.Background = new ImageBrush(source);
            image.Effect = effect;
            image.Measure(new Size(source.Width, source.Height));
            image.Arrange(new Rect(new Size(source.Width, source.Height)));
            bmp.Render(image);

            return BitmapFrame.Create(bmp);
        }

OK, ich glaube, dass ich das verstanden habe. Wenn ich mir den Konstruktor von RenderTargetBitmap ansehe, muss ich also bei pixelWidth und pixelHeight die pixelWidth und pixelHeight Werte des Quellbildes angeben, damit es korrekt erzeugt wird, nicht aber die Width und Height Werte. Ist das korrekt? Wenn ich dann die alten DPI-Werte übernehme müsste alles beim alten bleiben, oder? (Auflösung usw.)

Hi,

kann mir mal jemand den unterschied zwischen PixelWidth/Height und nur Width/Height erklären? Ich habe da ein seltsames Phänomen:

Auf einem Rechner ist scheinbar PixelWidth/Height und Width/Height identisch (nachgeprüft durch Debugging) und bei einem anderen nicht. Gab es im Framework irgendwelche BugFixes die dazu geführt haben?

Ich bin wirklich irretiert.

OK, Problem gelöst:
Man muss zusätzlich ViewportUnits auf Absolute setzen.

<DrawingBrush Viewport="0,0,25,25" TileMode="Tile" ViewportUnits="Absolute">
...
</DrawingBrush>

Naja, fast.

In diesem Beispiel wird das gekachelte Bild aber aufgestreckt, sobald man das zugrunde liegende Objekt vergrößert. Ich möchte aber, dass mehr Bildreihen und -Zeilen entstehen beim vergrößern des Objektes.

Ich versuche es mal anders zu beschreiben:
Ich habe einen "PaperSkin" erstellt. Dort soll auch eine mehrzeilige TextBox angezeigt werden. Meine Idee war, diese durch mehrere horizontale Linien anzudeuten. Das Problem ist aber, sobald ich die Höhe der TextBox ändere, bleiben es z. B. 5 Linien, aber der Abstand zwischen den Linien verändert sich. Ich will aber, dass es mehr oder weniger Linien werden.

Hi,

ich habe schon alles durchsucht, weiß im Endeffekt aber nicht wirklich, unter welchem Stichwort man da nachschalgen sollte.

Es geht um folgendes:
Ich möchte in WPF eine endlose Grafik zeichnen. D. h. z. B. wenn ich ein Raster mit der Pixelgröße 25x25 zeichnen möchte, dass diese Rastergröße auch beim aufstrecken des Objektes (z. B. Rechteck) bestehen bleibt. Im Endeffekt werden nur weitere Rasterelemente hinzugefügt oder entfernt. Geht so etwas?

Bei allen sachen, die ich bisher ausprobiert habe und im Netzt gefunden habe, wird das Bild immer aufgestreckt. Wenn ich das Aufstrecken verbiete, wird außenrum alles Transparent.

OK, danke.

Danke, hat funktioniert. Habe es aber erst nach ewiger suche im Code bemerkt, da dieser Fehler sehr indirekt auftrat.

Danke.

Hallo,

kann es sein, dass es beim Remoting in Zusammenhang mit WPF zu Schwierigkeiten kommt?

Folgendes: Ich habe einen einfachen Chat. Der Server besitzt die Methoden Login, Logout und SendMessage. Loggt sich ein User ein oder aus, so wird beim Client die Methode _UpdateList aufgerufen. Dies soll den Client dazu veranlassen, die Liste der Online-User zu aktualisieren. Wenn SendMessage auf dem Server aufgerufen wird, wird bei allen Clients die Methode _ReceiveMessage aufgerufen. Dadurch erhalten alle Clients die Information, dass ein String, der mit übertragen wird, angekommen ist.

Wenn ich einen Client anmelde, funktioniert alles, wenn ich aber einen zweiten Client am Server anmelde, erhalte ich einen Threadübergreifenden Fehler, wenn ich versuche, die Methode _UpdateList des Clients in der Liste auf dem Server aufzurufen.

Was passiert da? Warum geht das nicht? Welcher Thread ist überhaupt gemeint?

Hallo,

habe schon lange nicht mehr in C++ geschrieben und habe ein doch sehr seltsames Problem. Ich hoffe, ihr könnt mir weiterhelfen, auch wenn dies ein C# Forum ist...

Ich habe folgende Basis-Klasse:

class GUIBuilder
{
public:
	GUIBuilder(RenderWindow* win)
		: mWindow(win)
	{
	}
	virtual ~GUIBuilder()
	{
	}

	virtual QuickGUI::Sheet* getSheet() { return mSheet; }
	virtual void Build() { initSequence(); }
protected:
	RenderWindow* mWindow;
	QuickGUI::Sheet* mSheet;

	virtual void createSheet();
	virtual void createGUI() = 0;

	virtual void initSequence()
	{
		createSheet();
		createGUI();
	}
};

Dies ist die Ableitung:

class DefaultGUI : public GUIBuilder
{
public:
	DefaultGUI(RenderWindow* win, ExitListener* lst)
		: GUIBuilder(win), mExitLst(lst)
	{
	}
	~DefaultGUI()
	{
	}
protected:
	QuickGUI::Button* btnExit;
	ExitListener* mExitLst;

	void createGUI();
private:
	void btnExitClick(const QuickGUI::EventArgs &e);
};

Das Problem:

• 1: Ich kann kein Template-Pattern verwenden: Das, was ich in Build mache, würde ich schon gern in den Konstruktor packen, geht aber nicht, da dann ein Pure virtual method laufzeitfehler auftritt.
• 2: Wenn ich ein Objekt von DefaultGUI erzeuge (DefaultGUI* gui = new DefaultGUI(...)) wird der Konstruktor laut Debugger niemals aufgerufen, aber diese Codezeile! Wenn ich dann F11 drücke zum reinspringen, springt er direkt in die nächste Zeile, ohne in den Konstruktor rein zugehen. Der Konstruktor wird tatsächlich nicht aufgerufen, da das Objekt mExitLst 0 ist.

Was läuft da schief, warum wird das Objekt korrekt erzeugt, ruft aber niemals einen der Konstruktoren (weder der der Basis noch der der Ableitung) auf? Das verstößt doch gegen den logischen Sachverstand!

OK, danke für eure Hilfe.

Wie könnte ich das Problem umgehen? Soll ich die Position dann als "TEXCOORD2" tarnen?

Habe ich auch schon versucht, dann zeigt er mir den selben Fehler halt nur ohne die 0 an.

Hallo,

ich habe ein (für mich) unerklärliches Phänomen:

Ich habe folgenden HLSL Code:

float4x4 world;
float4x4 view;
float4x4 projection;

#define MAXIMUM 8

const float3 maximumNormal = float3(1, 0, 0);
const float PI = 3.1415;

float smoothing = 0.5f;
float minY = 0;
float maxY = 1;

int heightLevelCount = 0;
int cliffyLevelCount = 0;

float heightPercent[MAXIMUM];
float cliffyPercent[MAXIMUM];

texture heightLevel0;
texture heightLevel1;
texture heightLevel2;
texture heightLevel3;
texture heightLevel4;
texture heightLevel5;
texture heightLevel6;
texture heightLevel7;

texture cliffyLevel0;
texture cliffyLevel1;
texture cliffyLevel2;
texture cliffyLevel3;
texture cliffyLevel4;
texture cliffyLevel5;
texture cliffyLevel6;
texture cliffyLevel7;

//*******************************************************************************
//*******************************************************************************
//*******************************************************************************

sampler2D Image;

sampler2D HeightLevel[MAXIMUM] = 
{
	sampler_state
	{
	   Texture = <heightLevel0>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <heightLevel1>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <heightLevel2>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <heightLevel3>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <heightLevel4>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <heightLevel5>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <heightLevel6>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <heightLevel7>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	}
};

sampler2D CliffyLevel[MAXIMUM] = 
{
	sampler_state
	{
	   Texture = <cliffyLevel0>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <cliffyLevel1>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <cliffyLevel2>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <cliffyLevel3>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <cliffyLevel4>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <cliffyLevel5>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <cliffyLevel6>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	},

	sampler_state
	{
	   Texture = <cliffyLevel7>;
	   MinFilter = Point;
	   MagFilter = Linear;
	   MipFilter = Linear;
	}
};

//*******************************************************************************
//*******************************************************************************
//*******************************************************************************

struct INIT_INPUT
{
	float4 vPosition;
	float3 vNormal;
};

struct INIT_OUTPUT
{
	float height;
	float cliffy;
};

struct INDEX_OUTPUT
{
	int heightIndex;
	int cliffyIndex;
};

//*******************************************************************************
//*******************************************************************************
//*******************************************************************************

struct VS_OUTPUT
{
   float4 vPosition : POSITION0;
   float4 vDiffuse : COLOR0;
   float2 vTexCoord0: TEXCOORD0;
   float3 vNormal: TEXCOORD1;
};

struct VS_INPUT
{
   float4 vPos : POSITION0;
   float3 vNorm : NORMAL0;
   float4 vDif : COLOR0;
   float2 vTex0: TEXCOORD0;
};

struct PS_OUTPUT
{
   float4 RGBA: COLOR0;
};

//*******************************************************************************
//*******************************************************************************
//*******************************************************************************

INIT_OUTPUT InitValues(INIT_INPUT In)
{
	INIT_OUTPUT Out;
	
	//Compute the height and cliffy of pixel in percent (between 0 and 1)
   float dif = maxY - minY;
   Out.height = (In.vPosition.y - minY) / dif;
   Out.cliffy = 
		(In.vNormal.x * maximumNormal.x +	//Vec a * Vec b
		 In.vNormal.y * maximumNormal.y +
		 In.vNormal.z * maximumNormal.z) /
		(sqrt(								// |Vec a| * |Vec b|
			pow(In.vNormal.x, 2) +
			pow(In.vNormal.y, 2) +
			pow(In.vNormal.z, 2)
		 ) * sqrt(
			pow(maximumNormal.x, 2) +
			pow(maximumNormal.y, 2) +
			pow(maximumNormal.z, 2)
		));
	Out.cliffy = abs(acos(Out.cliffy)) / (PI / 2);
	if (Out.cliffy > 1) Out.cliffy = 1;
	if (Out.cliffy < 0) Out.cliffy = 0;
	
	return Out;
}

INDEX_OUTPUT GetLevelIndex(INIT_OUTPUT In)
{
	INDEX_OUTPUT Out;
	Out.heightIndex = -1;
	Out.cliffyIndex = -1;
	
	for(int i=0; i<heightLevelCount; i++)
		if (In.height < heightPercent[i])
		{
			Out.heightIndex = i;
			break;
		}
		
	for(int j=0; j<cliffyLevelCount; j++)
		if (In.cliffy < cliffyPercent[j])
		{
			Out.cliffyIndex = j;
			break;
		}
	
	return Out;
}

//*******************************************************************************
//*******************************************************************************
//*******************************************************************************

VS_OUTPUT RenderVS( VS_INPUT In )
{
   VS_OUTPUT Out;

   float4x4 WVP = mul(mul(world, view), projection);
   Out.vPosition = mul( In.vPos, WVP );

   Out.vDiffuse = In.vDif;
   Out.vTexCoord0 = In.vTex0;
   Out.vNormal = In.vNorm;

   return Out;
}

PS_OUTPUT RenderPS( VS_OUTPUT In )
{
   PS_OUTPUT Out;

   Out.RGBA = tex2D( Image, In.vTexCoord0 );
   
   /*float4 heightColors[MAXIMUM];
   for (int i=0; i<heightLevelCount; i++)
		heightColors[i] = tex2D( HeightLevel[i], In.vTexCoord0 );
		
   float4 cliffyColors[MAXIMUM];
   for (int j=0; j<cliffyLevelCount; j++)
		cliffyColors[j] = tex2D( CliffyLevel[j], In.vTexCoord0 );*/
		
	INIT_INPUT init;
	init.vPosition = In.vPosition;
	init.vNormal = In.vNormal;
		
   INIT_OUTPUT values = InitValues(init);   
   INDEX_OUTPUT indices = GetLevelIndex(values);
	
	//******************************************
	
	if (indices.heightIndex > -1)
		Out.RGBA = tex2D( HeightLevel[0], In.vTexCoord0 );
   
   return Out;
}

technique tec0
{
   pass p0
   {
      VertexShader = compile vs_2_0 RenderVS();
      PixelShader = compile ps_2_0 RenderPS();
   }
}

Ich erhalte an der Stelle

effect = Effect.FromString(DisplayDevice.ActiveDevice, data,
                ShaderFlags.None);

den Fehler: Invalid ps_2_0 input semantic: 'POSITION0'.

Wenn ich aber die Funktion InitValues wegnehme, dann wird dieser Fehler nicht mehr geworfen und es funktioniert (mehr oder weniger) alles.

Was soll das bedeuten? Wie kann ich das Problem beheben?

Versucht habe ich schon es auf Version 3.0 zu compilieren, dann aber haut der mir noch mehr Fehler rein, mit denen ich nichts anfangen kann, wie z. B. , dass alle Eingabe - Positionen aus mindestens 4 floats bestehen müssen, obwohl ich schon ein float4 implementiert habe.

OK, Danke für eure Hilfe.

Hi,

folgendes Problem:

Ich habe eine source Voice für ein Sound - Objekt und möchte nach dem Aufruf von Stop, dass die Abspielposition wieder zurück auf den Nullpunkt springt. Bis jetzt habe ich keine Möglichkeit dafür gefunden, der Sound wird immer wieder von der gestoppten Stelle aus weiter abgespielt. Ich kann dies nur dadurch erreichen, in dem ich die Datei komplett neu lade. Das ist aber extrem störend, da das unnötige Neuladen den Prozess extrem blockiert.

        public virtual void Start()
        {
            if (IsClosed)
                throw new SoundClosedException();

            sourceVoice.Start();
            IsStarted = true;
        }

        public virtual void Pause()
        {
            if (IsClosed)
                throw new SoundClosedException();

            sourceVoice.Stop();
            IsStarted = false;
        }

        public virtual void Stop()
        {
            if (IsClosed)
                throw new SoundClosedException();

            sourceVoice.Stop();
            IsStarted = false;
            Reopen(); //Unnötig und extrem belastend
        }

Kann mir jemand weiter helfen?

Vielen Dank für eure Antworten.

Ich habe es mal ausprobiert und es hat sofort geklappt.

Nun noch eine Frage: Kann man die WPF-Komponenten im Vollbildmodus erhalten? Gibt es da eine Möglichkeit zu?

Hi,

gibt es eine Möglichkeit, SlimDX und WPF miteinander zu verbinden? Dann wäre ich das GUI - Problem los.

PS: WPF ist selbst nicht dafür geeignet auf Direct3D zuzugreifen, da das System auf Knoten basiert. Diese sind aber meines Erachtens schwerer zu benutzen.

OK, dann danke!

Hi,

gibt es eine Möglichkeit, Events weiterzuleiten?

Folgendes Beispiel: Ich habe eine ComboBox. Neues Template wird für diese erstellt, darin wird ein neuer ToggleButton (rechts) und ein neues Label (links) erzeugt. Für diese werden lokal neue Templates erstellt.

Wenn ich jetzt auf die ComboBox drauf gehe, möchte ich, dass das MouseEnter - Event für beide Elemente ausgelöst werden. Also soll das Event der ComboBox, nicht aber des Buttons oder des Labels geworfen werden.

Gehts das irgendwie?

Danke, es war wirklich ein Problem der Reihenfolge.
Ich habe es jetzt so gelöst:

                        <Trigger Property="IsSelected" Value="true">
                            <Setter TargetName="Border" Property="Background" Value="Yellow"/>
                        </Trigger>
                        
                                            
                        <MultiTrigger>
                            <MultiTrigger.Conditions>
                                <Condition Property="IsSelected" Value="false"/>
                                <Condition Property="IsMouseOver" Value="false"/>
                            </MultiTrigger.Conditions>
                            <MultiTrigger.EnterActions>
                                <BeginStoryboard>
                                    <Storyboard>
                                        <ColorAnimation
                                        Storyboard.TargetName="Border"
                                        Storyboard.TargetProperty="Background.Color"
                                        To="SkyBlue" AutoReverse="False" Duration="0:0:0.5"/>
                                    </Storyboard>
                                </BeginStoryboard>
                            </MultiTrigger.EnterActions>
                            <MultiTrigger.ExitActions>
                                <BeginStoryboard>
                                    <Storyboard>
                                        <ColorAnimation
                                        Storyboard.TargetName="Border"
                                        Storyboard.TargetProperty="Background.Color"
                                        To="AliceBlue" AutoReverse="False" Duration="0:0:0.5"/>
                                    </Storyboard>
                                </BeginStoryboard>
                            </MultiTrigger.ExitActions>
                        </MultiTrigger>

Hi,

ich habe ein Template für ein ListBoxItem neu geschrieben und wollte es gern so aufbauen, dass, wenn man mit der Maus drüber fährt, das Item aufleuchtet (Background / ColorAnimation / MouseEnter und MouseLeave) und wenn es selektiert wird, eine andere Farbe erhält (Background / Setter).
Das Problem: Wenn ich es selektiert habe und mit der Maus runterfahre, dann wird die Selektion ausgeblendet, da ja das MouseLeave - Event geworfen wird.

Ich habe mich da schon mit MultiTriggern rumgeschlagen, aber bis jetzt habe ich keine Lösung gefunden. Allerdings glaube ich, dass dies ein häufiges Problem ist. Kennt jamnd zufällig eine Lösung?

<EventTrigger RoutedEvent="MouseEnter">
<!--ColorAnimation-->
</EventTrigger>

<EventTrigger RoutedEvent="MouseLeave">
<!--ColorAnimation-->
</EventTrigger>

<Trigger Property="IsSelected" Value="true">
 <Setter TargetName="Border" Property="Background" Value="Yellow"/>
</Trigger>

Du hast was falsches verwendet. Du darfst nicht den GridViewRowPresenter verwenden, sondern den ScrollControlPresenter. Dann geht es.

Hallo,

hat irgendwer eine Ahnung, wie man einen IFD Handler am Betriebssystem anmeldet?

Folgende Grundlage:

Ich habe eine DLL in C++ geschrieben, die sich an das IFD Handler - Interface hält. Die Methoden, die dafür benötigt werden, sind nach Außen freigegeben (dllexport). Da laut der Beschreibungen, die ich gefunden habe, alles so ok sein müsste, muss ich dem Betriebssystem Windows nun beibringen, das es sich bei der DLL um einen IFD Handler handelt, damit der ICC Resource Manager (Betreibssystemseite) auf diese DLL drauf geht.

Kann mir da jemand helfen?

OK, vielen Dank!

Hi,

kann mir jemand sagen, ob das btspp-Verfahren ähnlich, wie bei TCP, bestätigt, ob die Datenpakete angekommen sind oder ob es, ähnlich wie bei UDP, so ist, dass er nicht weiß, ob die Datenpakete angekommen sind?

Wäre schön, wenn ich eine schnelle Antwort bekomme.

Danke! 😉

Sorry, das ist aber sehr unsauber und funktioniert nur teilweise.
Folgendes Szenario:

Ich klicke auf einen Button, wodurch eine Liste auf der Form erscheint. Diese wurde durch Visible=False im Designer unsichtbar gemacht, wird dann bei dem Button mit Visible = true wieder sichtbar gemacht.
Wenn man nun die Components neu macht, wird der Zustand des Objektes zurückgesetzt. Die Liste verschwindet.

Das ist eher schlecht.

Hi,

die Frage kommt bestimmt oft, aber wie kann man mit DirectX genau auf den Desktop-Hintergrund (Ebene hinter den Icons und den Mini-Anwendungen) unter Win7 zeichnen? Ich habe doch mal gehört, dass unter dieser Windows-Version bereits alles mit DirectX gerendert werden soll.

Komme ich in diese Ebene?

Danke, Momentan suche ich aber eine Alternative zu Wiggles.

Hi,

nun suche ich ein Spiel, dass dem Spiel Wiggles sehr ähnlich ist. Ich hoffe, dass jem and dieses Spiel kennt. Das Problem ist, dass dieses Spiel zwar noch funktioniert, aber bereits erheblich überaltert ist und deswegen Funktionalitäten nicht mehr korrekt funktionieren.

Danke!

Ja, danke, dass hilft weiter.

@kleines_eichhoernchen:
Leider kann ich deiner Argumentation nicht folgen, da dies gegen die Vorschrift für Objekte verstößt, sofern diese Werte haben. Die Methode ReferenceEquals sollte immer über == verwendet werden. Equals ist für Wert-Vergleiche da. Der ==-Operator kann bei immutable-Objekten überschrieben werden. Equals kann aber auch bei veränderlichen Objekten verwendet werden.
Dazu folgender Link:
Richtlinien zum Überladen von Equals() und des ==-Operators (C#-Programmierhandbuch)

Du kannst dir auch einfach so (ohne BindingFlags) die PropertyInfos ermitteln und dann mittels
> gucken, welcher Typ (in der Vererbungshierarchie) das Property deklariert/zuletzt überschrieben hat.

Das bringt mir ja nichts, dass weiß ich ohnehin schon.
Hier mal die Klasse, in der ich das Brauche (ist auskommentiert):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace Tools
{
    /// <summary>
    /// Tools für die einfache Behandlung von HashCodes und Equals
    /// </summary>
    public static class DefaultEHTools
    {
        /// <summary>
        /// Erzeugt ein Standard-Equals
        /// </summary>
        /// <typeparam name="T">Typ des zu vergleichenden Objektes</typeparam>
        /// <param name="thisObj">Das This-Objekt. <b>Hier immer <i><u>this</u></i> übergeben</b></param>
        /// <param name="obj">Das Objekt, welches übergeben wurde</param>
        /// <returns>TRUE, wenn absolut gleich</returns>
        public static bool CreateEquals<T>(T thisObj, object obj) where T : class
        {
            //Standard-Test
            if (obj == null)
                return false;
            else if (!(obj is T))
                return false;
            else if (Object.ReferenceEquals(thisObj, obj))
                return true;

            //Umwandlung
            T myObj = obj as T;

            //Ermittlung der Properties
            PropertyInfo[] props = typeof(T).GetProperties();
            foreach (PropertyInfo pi in props)
            {   //Überspringen, wenn Equals von der Property-Klasse nicht implementiert wurde
                /*if (pi.PropertyType.GetMethod("Equals", BindingFlags.IgnoreCase | BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public) == null)
                {
                    Console.WriteLine("Overjump: " + pi.Name + " (" + pi.PropertyType.Name + ")");
                    continue;
                }*/

                //Lesbar?
                if (pi.CanRead)
                {   //Inhalte ermitteln
                    object value1 = pi.GetValue(thisObj, null);
                    object value2 = pi.GetValue(myObj, null);

                    //Standard-Vergleich bei NULL und nicht NULL
                    if (((value1 == null) && (value2 != null)) ||
                        ((value1 != null) && (value2 == null)))
                        return false;
                    //Vergleich mit Equals, wenn Objekte nicht NULL
                    else if ((value1 != null) && (value2 != null))
                    {
                        if (!value1.Equals(value2))
                            return false;
                    }
                    //Sonst sind beide NULL, also beide gleich
                }
            }

            //Wenn überall durchgelaufen, alles OK
            return true;
        }

        /// <summary>
        /// Ermittelt den Standard-HashCode
        /// </summary>
        /// <typeparam name="T">Typ des zu vergleichenden Objektes</typeparam>
        /// <param name="thisObj">Das This-Objekt. <b>Hier immer <i><u>this</u></i> übergeben</b></param>
        /// <returns>HashCode-Wert</returns>
        public static int CreateHashCode<T>(T thisObj) where T : class
        {
            int res = 0;
            int prime = new Random().Next() % 25 + 5;

            PropertyInfo[] props = typeof(T).GetProperties();
            foreach (PropertyInfo pi in props)
            {   //Überspringen, wenn GetHashCode von der Property-Klasse nicht implementiert wurde
                /*if (pi.PropertyType.GetMethod("GetHashCode", BindingFlags.IgnoreCase | BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public) == null)
                {
                    Console.WriteLine("Overjump: " + pi.Name + " ("+pi.PropertyType.Name+")");
                    continue;
                }*/
                
                //Lesbar?
                if (pi.CanRead)
                {   //Inhalte ermitteln
                    object value = pi.GetValue(thisObj, null);

                    //Wenn nicht NULL, dann HashCode ermitteln, sonst nicht
                    if (value != null)
                        res = res * prime + value.GetHashCode();
                    else
                        res = res * prime;
                }
            }

            //Rückgabe des Wertes
            return res;
        }
    }
}

Ich hoffe, dass hilft fürs bessere Verständnis...

Ganz wichtig (ich habe es gerade extra nochmal in [Artikel] Reflection und Metaprogrammierung besonders hervorgehoben):
Bei der Verwendung von BindingFlags müssen immer sowohl Zugriffsmodifizier (BindingFlags.Public, BindingFlags.NonPublic, etc.) als auch BindingFlags.Static und/oder BindingFlags.Instance angeben werden! Sonst erhält man nur leere Listen bzw. null zurück.

Das habe ich auch schon probiert:

if (pi.PropertyType.GetMethod("Equals", BindingFlags.IgnoreCase | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance) == null)
{
  continue; //Für Schleife mit allen Props
}

Dann erhalte ich aber eine Exception mit der Meldung:
Mehrdeutige Übereinstimmung gefunden!

Das geht auch nicht...

Ähm, naja, im Normal-Zustand ist das Equals, wenn es von Object geerbt ist, nur ein Object.ReferenceEquals. Ich will ja nicht die Referenzen überprüfen, sondern die Gleichheit der Objekte selbst.
Zudem ist es so, dass ohnehin jede Klasse Equals überschreiben sollte (und GetHashCode). Insbesondere, wenn diese Klasse aus dem Framework stammt und daher nicht mehr veränderbar ist.

Hi,

ich habe ein Problem: Unter WinXP erhalte ich aus der Klasse IPAddress bei der Methode ToString() eine IPv4-Adresse (127.0.0.1) zurück, unter Vista eine IPv6-Adresse. Wenn ich aber mein Server-Objekt holen möchte, muss ich schon wissen, ob es sich um eine IPv4- oder IPv6-Adresse handelt.

IServer server = (IServer)Activator.GetObject(typeof(IServer), "tcp://"+ip.ToString()+":"+port-ToString()+"/"+SERVERNAME);

Bei IPv6 muss man ja eckige Klammern angeben, bei IPv4 aber nicht...

IServer server = (IServer)Activator.GetObject(typeof(IServer), "tcp://["+ip.ToString()+"]:"+port-ToString()+"/"+SERVERNAME);

Habt ihr eine Lösung?

Versuch doch mal folgendes:
Reagiere darauf, wenn das Programm beendet wird. Bei der Console wäre es so, dass du, wenn aller Code beendet wird (also theoretisch am Ende der Main-Funktion), einfach dort einen neuen unabhängigen Prozess startest, der dein Programm selbst aufruft.

Über Application.ApplicationExit (event) kannst du auch reagieren, wenn die Anwendung (durch was auch immer) beendet wird. Dort startest du dann den Prozess neu.

Hilft dir das erstmal weiter?

Hi,

es geht um folgendes Problem:
Ich schreibe mir zur Zeit einen Equals-Builder. Dieser geht einfach alle Props durch, die er lesen kann, und vergleicht diese mittels Equals. Das Problem: Wie finde ich mittels Reflection heraus, ob die Propery-Klasse Equals überschrieben hat?

Ich hatte dazu folgenden Ansatz:
(PI = Property-Info-Objekt)

if (pi.PropertyType.GetMethod("Equals", BindingFlags.IgnoreCase | BindingFlags.DeclaredOnly) == null) 
{
  continue; //Für Schleife mit allen Props
}

Das geht aber nicht, da immer NULL rauskommt.

Wisst ihr, wie es geht?