j.klugmann hat geschrieben:Ansonsten lösche per Hand alle Object-Files und versuche mal komplett neu zu kompilieren.
Wird nach Artificial Mind's Vorschlag gemacht. Egentlich hatte ich aber nach dem ändern der Runtime-DLL einen Full-Build hinter mir. Vielleicht hilft's ja trotzdem.
j.klugmann hat geschrieben:Ansonsten solltest du vielleicht mal etwas Source zeigen...
Gerne, ich frage mich nur von was genau?
Hier ist mein Licht (Vorsicht, musste mehrere Tage wütendes herrumfrikeln über sich ergehen lassen!):
Code: Alles auswählen
#pragma once
#include "DXUT.h"
#include "WBaseLightComponent.h"
#include "ScreenQuadHelper.h"
class EditorLinePrimitive;
class WShader;
class SceneRenderer_ToDepthBuffer;
class WDirectionalLightComponent:public WBaseLightComponent
{
public:
WDirectionalLightComponent();
~WDirectionalLightComponent();
/** Basic component functions */
virtual void OnCreate();
virtual void RenderComponent(int NumInst,bool bSelected=false);
virtual void PreRenderContentMark();
/** Called when the shadowmapping property has changed */
void UseShadowmapPropertyChanged();
/** Sets the pointer to the property container */
virtual void SetPropertyContainer(wpsPropertyContainer* NewContainer);
private:
/** Info primitive */
EditorLinePrimitive* InfoPrimitive;
/** Shadow map renderer */
SceneRenderer_ToDepthBuffer* ShadowMapRenderer;
SceneRenderer_ToDepthBuffer* ShadowMapRenderer2;
SceneRenderer_ToDepthBuffer* ShadowMapRenderer3;
/** Properties */
wColorProperty* IndirectLightingColorProperty;
wBoolProperty* UseShadowmappingProperty;
wFloatProperty* CascadeScaleProperty;
/////////// Neue Properties, die ich für die GodRays eingefügt hatte. Nach dem Auskommentieren gabs keine Crashes mehr ///////////
/*wBoolProperty* bRenderGodRaysProperty;
wFloatProperty* GodRayDensityProperty;
wFloatProperty* GodRayWeightProperty;
wFloatProperty* GodRayDecayProperty;
wColorProperty* GodRayColorModProperty;
wFloatProperty* GodRayMinimumBrightnessProperty;*/
int Test1; // <----- Hier sind meine Test-Ints. Manchmal (immer?) reicht auch schon eines davon um die Sache abstürzen zu lassen.
int Test2;
int Test3;
int Test4;
int Test5;
int Test6;
/** Shader custom variables */
int LightDirectionIndex;
int NormalTexIndex;
int DepthTexIndex;
int IndirLightingColorIndex;
int ProjABIndex;
int invProjIndex;
int LightViewProjMatrixIndex;
int LightViewProjMatrix2Index;
int LightViewProjMatrix3Index;
int invViewMatrixIndex;
int ShadowMap1Index;
int ShadowMap2Index;
int ShadowMap3Index;
/** Screenquad-Mesh */
ScreenQuadHelper ScreenQuad;
/** Shader for pointlight */
WShader* LightShader;
};
Konstruktor + Init-Funktion:
Code: Alles auswählen
#include "DXUT.h"
#include "WDirectionalLightComponent.h"
#include "EditorLinePrimitive.h"
#include "SceneRenderer_ToDepthBuffer.h"
#include "WCamera.h"
#include "WContentMark.h"
#include "SharedParameters.h"
#include "WTechPackage2.h"
#include "WPckFileChunk.h"
#include "PackageHandler.h"
#include "AllClasses.h"
#include "PostFX_GodRays.h"
WDirectionalLightComponent::WDirectionalLightComponent()
{
bDeleted = false;
MyClass=WDIRECTIONALLIGHTCOMPONENT;
bLetMeDoTheRenderGroupCheck = true;
ShadowMapRenderer=NULL;
ShadowMapRenderer2=NULL;
ShadowMapRenderer3=NULL;
IndirectLightingColorProperty = Properties->CreateColor("Indirect Lightcolor");
IndirectLightingColorProperty->Set(&D3DXVECTOR4(0.5, 0.5, 0.5, 0));
UseShadowmappingProperty = Properties->CreateBool("Shadows");
UseShadowmappingProperty->Set(false);
CascadeScaleProperty = Properties->CreateFloat("Cascade Scale");
CascadeScaleProperty->Set(1.0f);
/*bRenderGodRaysProperty = Properties->CreateBool("Render GodRays");
bRenderGodRaysProperty->Set(false);
GodRayDensityProperty = Properties->CreateFloat("GodRays Density");
GodRayDensityProperty->Set(0.5);
GodRayWeightProperty = Properties->CreateFloat("GodRays Weight");
GodRayWeightProperty->Set(0.6);
GodRayDecayProperty = Properties->CreateFloat("GodRays Decay");
GodRayDecayProperty->Set(0.9);
GodRayMinimumBrightnessProperty = Properties->CreateFloat("GodRays Minimum Brightness");
GodRayMinimumBrightnessProperty->Set(0.7);
GodRayColorModProperty = Properties->CreateColor("GodRays Color");
GodRayColorModProperty->Set(&D3DXVECTOR4(1,1,1,1));*/
InfoPrimitive = new EditorLinePrimitive;
}
/////////// Optimierungen natürlich nur aus damit ich hier ordentlich debuggen kann ///////////
#pragma optimize( "", off )
void WDirectionalLightComponent::OnCreate()
{
WBaseLightComponent::OnCreate();
HRESULT hr;
// Find light shader in media package
WTechPackage2* MediaPack;
SharedParams->PckHandler->FindPackageByName(L"EngineMedia.wpk", &MediaPack);
LightShader=(WShader *)MediaPack->GetChunkByName(L"DirectionalLightShader.wfx")->GetOwnedObject();
ScreenQuad.CreateQuad();
ScreenQuad.SetShader(LightShader);
LightShader->AddCustomVariable("LightDirection",CVT_VECTOR,&LightDirectionIndex);
LightShader->AddCustomVariable("NormalTex",CVT_SHADER_RES_VIEW,&NormalTexIndex);
LightShader->AddCustomVariable("IndirectLightColor",CVT_VECTOR,&IndirLightingColorIndex);
LightShader->AddCustomVariable("DepthTex",CVT_SHADER_RES_VIEW,&DepthTexIndex);
LightShader->AddCustomVariable("ProjAB",CVT_VECTOR,&ProjABIndex);
LightShader->AddCustomVariable("invProj",CVT_VECTOR,&invProjIndex);
LightShader->AddCustomVariable("invView",CVT_MATRIX,&invViewMatrixIndex);
LightShader->AddCustomVariable("LightViewProjMatrix",CVT_MATRIX,&LightViewProjMatrixIndex);
LightShader->AddCustomVariable("LightViewProjMatrix2",CVT_MATRIX,&LightViewProjMatrix2Index);
LightShader->AddCustomVariable("LightViewProjMatrix3",CVT_MATRIX,&LightViewProjMatrix3Index);
LightShader->AddCustomVariable("ShadowMap1",CVT_SHADER_RES_VIEW,&ShadowMap1Index);
LightShader->AddCustomVariable("ShadowMap2",CVT_SHADER_RES_VIEW,&ShadowMap2Index);
LightShader->AddCustomVariable("ShadowMap3",CVT_SHADER_RES_VIEW,&ShadowMap3Index);
// Init our Line-Primitive
InfoPrimitive->CreateArrowPrimitive(&WBASELIGHTCOMPONENT_LINE_COLOR);
InfoPrimitive->SetShader((WShader *)MediaPack->GetChunkByName(L"ColoredLinePrimitiveShader.wfx")->GetOwnedObject());
}
#pragma optimize( "", on )
Erstellung des Objektes:
Code: Alles auswählen
WObject* WPckFileChunk::CreateOwnedObject(WClass ObjectClass,int Index,bool bContentMarkTarget)
{
if(Index<MaxOwnedObjects)
{
// CreateObjByClass() beinhaltet nur ein großes, generiertes, switch-statement in dem für das hier dieser code ausgeführt wird:
// case WDIRECTIONALLIGHTCOMPONENT:
// *Out=new WDirectionalLightComponent;
// return true;
CreateObjByClass(ObjectClass,(void **)&OwnedObject[Index]);
if(OwnedObject[Index])
{
//OnCreatedContentObject(OwnedObject[Index],false);
Box->RegisterObject(OwnedObject[Index]);
OwnedObject[Index]->SetMyFileChunk(this);
}
ContentMarkTargetObject=Index;
return OwnedObject[Index];
}else
{
LogError() << L"Failed to create owned object. Index exceeds" << MaxOwnedObjects-1;
return NULL;
}
}
Edit: Ohne PageHeap crasht es hier:
Code: Alles auswählen
/** Creates the buffers and sets up the rest of the object */
HRESULT EditorLinePrimitive::CreatePrimitive(VertexStruct* PrimVerts, UINT NumVertices, D3D11_PRIMITIVE_TOPOLOGY Topology)
{
HRESULT hr=S_OK;
// Clean up previous data
DeleteContent();
// Copy over the new data
Vertices = new VertexStruct[NumVertices]; // <------ Crash hier, bei "_heap_alloc"
memcpy(Vertices, PrimVerts, sizeof(VertexStruct)*NumVertices);
this->NumVertices = NumVertices;
//Create the vertex buffer
D3D11_BUFFER_DESC bufferDesc;
bufferDesc.ByteWidth = NumVertices * sizeof(VertexStruct);
bufferDesc.Usage = D3D11_USAGE_DEFAULT;
bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.CPUAccessFlags = 0;
bufferDesc.MiscFlags = 0;
D3D11_SUBRESOURCE_DATA InitData;
InitData.pSysMem = &Vertices[0];
InitData.SysMemPitch = 0;
InitData.SysMemSlicePitch = 0;
LE(DXUTGetD3D11Device()->CreateBuffer(&bufferDesc,&InitData,&PrimVB));
PrimitiveTopology = Topology;
return hr;
}
/** Creates an arrow of lines */
HRESULT EditorLinePrimitive::CreateArrowPrimitive(const D3DXVECTOR4* Color,float ArrowRadius, float ArrowOffset)
{
VertexStruct vx[10];
// Middle streak
vx[0].Position = D3DXVECTOR3(0, 0, 0);
vx[1].Position = D3DXVECTOR3(1, 0, 0);
// Outer lines
vx[2].Position = D3DXVECTOR3(1, 0, 0);
vx[3].Position = D3DXVECTOR3(ArrowOffset, ArrowRadius, ArrowRadius);
vx[4].Position = D3DXVECTOR3(1, 0, 0);
vx[5].Position = D3DXVECTOR3(ArrowOffset, ArrowRadius, -ArrowRadius);
vx[6].Position = D3DXVECTOR3(1, 0, 0);
vx[7].Position = D3DXVECTOR3(ArrowOffset, -ArrowRadius, ArrowRadius);
vx[8].Position = D3DXVECTOR3(1, 0, 0);
vx[9].Position = D3DXVECTOR3(ArrowOffset, -ArrowRadius, -ArrowRadius);
for(int i=0; i< 10; i++)
{
EncodeColor(&vx[i], Color);
}
HRESULT hr = CreatePrimitive(vx, 10);
return hr;
}
