sdk editors

src/Common/Common.vcxproj

@@ -76,6 +76,7 @@
     <ClInclude Include="Platform.hpp" />
     <ClInclude Include="PlatformLinux.inl" />
     <ClInclude Include="PlatformWindows.inl" />
+    <ClInclude Include="RDevice.h" />
     <ClInclude Include="Util.hpp" />
     <ClInclude Include="_d3d_extensions.h" />
   </ItemGroup>

src/Common/Common.vcxproj.filters

@@ -92,6 +92,7 @@
       <Filter>Externals</Filter>
     </ClInclude>
     <ClInclude Include="OGF_GContainer_Vertices.hpp" />
+    <ClInclude Include="RDevice.h" />
   </ItemGroup>
   <ItemGroup>
     <Filter Include="NvMender2003">

src/Common/LevelGameDef.h

@@ -22,6 +22,7 @@ enum ERPpointType
     rptActorSpawn = 0,
     rptArtefactSpawn,
     rptItemSpawn,
+    rptTeamBaseParticle = rptItemSpawn,
     rptLast = 0xff
 };
 
@@ -35,14 +36,9 @@ enum EEnvModUsedParams
     eHemiColor = (1 << 5)
 };
 
-/* // XXX: find better place for this (need cpp)
-xr_token rpoint_type[] = {
-    {"Actor Spawn", rptActorSpawn},
-    {"Artefact Spawn", rptArtefactSpawn},
-    {"Item Spawn", rptItemSpawn},
-    {nullptr, rptLast}
-};
-*/
+extern xr_token rpoint_type[];
+extern xr_token rpoint_type_soc[];
+extern const xr_token rpoint_game_type[];
 
 // BASE offset
 #define WAY_BASE 0x1000

src/Common/RDevice.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#ifndef _EDITOR
+#define RDEVICE Device
+#else
+#define RDEVICE EDevice
+#endif

src/Include/xrAPI/xrAPI.h

@@ -22,16 +22,16 @@ class UICore;
 class XRAPI_API EngineGlobalEnvironment
 {
 public:
-    IRender* Render;
     IDebugRender* DRender;
     CDUInterface* DU;
     IUIRender* UIRender;
-    IRenderFactory* RenderFactory;
     CScriptEngine* ScriptEngine;
-    AISpaceBase* AISpace;
-    ISoundManager* Sound;
+    AISpaceBase* AISpace;    
     UICore* UI;
 
+    ISoundManager* Sound;
+    IRender* Render;
+    IRenderFactory* RenderFactory;
     bool isDedicatedServer;
 };
 

src/Include/xrRender/FactoryPtr.h

@@ -79,6 +79,7 @@ FACTORY_PTR_INSTANCIATE(EnvironmentRender)
 FACTORY_PTR_INSTANCIATE(EnvDescriptorRender)
 #endif // _EDITOR
 FACTORY_PTR_INSTANCIATE(FontRender)
+
 /*
 void FactoryPtr<IStatsRender>::CreateObject(void)
 {

src/Include/xrRender/RenderFactory.h

@@ -62,6 +62,7 @@ class IRenderFactory
     RENDER_FACTORY_INTERFACE(FlareRender)
 #endif // _EDITOR
     RENDER_FACTORY_INTERFACE(FontRender)
+
 protected:
     // virtual IEnvDescriptorRender *CreateEnvDescriptorRender() = 0;
     // virtual void DestroyEnvDescriptorRender(IEnvDescriptorRender *pObject) = 0;

src/Layers/xrRender/Blender.cpp

@@ -19,15 +19,11 @@ void CBlender_DESC::Setup(LPCSTR N)
     xr_strlwr(cName);
 
     xr_strcpy(cComputer, Core.CompName); // Computer
-#ifndef _EDITOR
+
 #if defined(XR_PLATFORM_WINDOWS) // TODO Implement for Linux
     _tzset();
     _time32((__time32_t*)&cTime); // Time
 #endif
-#else
-    _tzset();
-    time((long*)&cTime); // Time
-#endif
 };
 
 //////////////////////////////////////////////////////////////////////
@@ -84,6 +80,7 @@ void IBlender::Compile(CBlender_Compile& C)
         C.SetParams(oPriority.value, oStrictSorting.value ? true : false);
 }
 
+#ifndef _EDITOR
 IBlender* IBlender::Create(CLASS_ID cls)
 {
     return ::RImplementation.blender_create(cls);
@@ -93,3 +90,49 @@ void IBlender::Destroy(IBlender*& B)
 {
     ::RImplementation.blender_destroy(B);
 }
+#else
+
+// Editor
+#include "blenders/BlenderDefault.h"
+#include "blenders/Blender_default_aref.h"
+#include "blenders/Blender_Vertex.h"
+#include "blenders/Blender_Vertex_aref.h"
+#include "blenders/Blender_Screen_SET.h"
+#include "blenders/Blender_Screen_GRAY.h"
+#include "blenders/Blender_Editor_Wire.h"
+#include "blenders/Blender_Editor_Selection.h"
+#include "blenders/Blender_LaEmB.h"
+#include "blenders/Blender_Lm(EbB).h"
+#include "blenders/Blender_BmmD.h"
+#include "blenders/Blender_Model.h"
+#include "blenders/Blender_Model_EbB.h"
+#include "blenders/Blender_detail_still.h"
+#include "blenders/Blender_tree.h"
+#include "blenders/Blender_Particle.h"
+
+IBlender* IBlender::Create(CLASS_ID cls)
+{
+    switch (cls)
+    {
+    case B_DEFAULT: return xr_new<CBlender_default>();
+    case B_DEFAULT_AREF: return xr_new<CBlender_default_aref>();
+    case B_VERT: return xr_new<CBlender_Vertex>();
+    case B_VERT_AREF: return xr_new<CBlender_Vertex_aref>();
+    case B_SCREEN_SET: return xr_new<CBlender_Screen_SET>();
+    case B_SCREEN_GRAY: return xr_new<CBlender_Screen_GRAY>();
+    case B_EDITOR_WIRE: return xr_new<CBlender_Editor_Wire>();
+    case B_EDITOR_SEL: return xr_new<CBlender_Editor_Selection>();
+    case B_LaEmB: return xr_new<CBlender_LaEmB>();
+    case B_LmEbB: return xr_new<CBlender_LmEbB>();
+    case B_BmmD: return xr_new<CBlender_BmmD>();
+    case B_MODEL: return xr_new<CBlender_Model>();
+    case B_MODEL_EbB: return xr_new<CBlender_Model_EbB>();
+    case B_DETAIL: return xr_new<CBlender_Detail_Still>();
+    case B_TREE: return xr_new<CBlender_Tree>();
+    case B_PARTICLE: return xr_new<CBlender_Particle>();
+    }
+    return 0;
+}
+void IBlender::Destroy(IBlender*& B) { xr_delete(B); }
+
+#endif

src/Layers/xrRender/Blender.h

@@ -49,6 +49,7 @@ class ECORE_API IBlender : public CPropertyBase
 public:
     static IBlender* Create(CLASS_ID cls);
     static void Destroy(IBlender*& B);
+    static void CreatePalette(xr_vector<IBlender*>& palette);
 
     CBlender_DESC& getDescription() { return description; }
     virtual LPCSTR getName() { return description.cName; }

src/Layers/xrRender/Blender_Palette.cpp

@@ -0,0 +1,59 @@
+#include "stdafx.h"
+#include "Blender.h"
+#include "blender_clsid.h"
+
+IC bool p_sort(IBlender *A, IBlender *B)
+{
+	return stricmp(A->getComment(), B->getComment()) < 0;
+}
+
+#define TYPES_EQUAL(A, B) (typeid(A).raw_name() == typeid(B).raw_name())
+
+void IBlender::CreatePalette(xr_vector<IBlender *> &palette)
+{
+	// Create palette itself
+	R_ASSERT(palette.empty());
+	palette.push_back(Create(B_DEFAULT));
+	palette.push_back(Create(B_DEFAULT_AREF));
+	palette.push_back(Create(B_VERT));
+	palette.push_back(Create(B_VERT_AREF));
+	palette.push_back(Create(B_SCREEN_SET));
+	palette.push_back(Create(B_SCREEN_GRAY));
+	palette.push_back(Create(B_EDITOR_WIRE));
+	palette.push_back(Create(B_EDITOR_SEL));
+	palette.push_back(Create(B_LIGHT));
+	palette.push_back(Create(B_LaEmB));
+	palette.push_back(Create(B_LmEbB));
+	palette.push_back(Create(B_BmmD));
+	palette.push_back(Create(B_B));
+	palette.push_back(Create(B_SHADOW_WORLD));
+	palette.push_back(Create(B_BLUR));
+	palette.push_back(Create(B_MODEL));
+	palette.push_back(Create(B_MODEL_EbB));
+	palette.push_back(Create(B_DETAIL));
+	palette.push_back(Create(B_TREE));
+	palette.push_back(Create(B_PARTICLE));
+
+	// Remove duplicated classes (some of them are really the same in different renderers)
+	for (u32 i = 0; i < palette.size(); i++)
+	{
+		IBlender *A = palette[i];
+		for (u32 j = i + 1; j < palette.size(); j++)
+		{
+			IBlender *B = palette[j];
+			if ((A && B) && TYPES_EQUAL(*A, *B))
+			{
+				xr_delete(palette[j]);
+				j--;
+			}
+		}
+	}
+	for (u32 i = palette.size(); i != 0; i--)
+	{
+		u32 real_i = i - 1;
+		if (!palette[real_i])
+			palette.erase(palette.begin() + real_i);
+	}
+	// Sort by desc and return
+	std::sort(palette.begin(), palette.end(), p_sort);
+}

src/Layers/xrRender/Blender_Recorder_StandartBinding.cpp

@@ -6,7 +6,12 @@
 #include "Blender.h"
 
 #include "xrEngine/IGame_Persistent.h"
+
+#ifndef _EDITOR
 #include "xrEngine/Environment.h"
+#endif
+
+#include "Common/RDevice.h"
 
 // matrices
 #define BIND_DECLARE(xf)\
@@ -67,8 +72,8 @@ class cl_texgen : public R_constant_setup
         Fmatrix mTexgen;
 
 #if defined(USE_DX9)
-        float _w = float(Device.dwWidth);
-        float _h = float(Device.dwHeight);
+        float _w = float(RDEVICE.dwWidth);
+        float _h = float(RDEVICE.dwHeight);
         float o_w = (.5f / _w);
         float o_h = (.5f / _h);
         Fmatrix mTexelAdjust =
@@ -111,8 +116,8 @@ class cl_VPtexgen : public R_constant_setup
         Fmatrix mTexgen;
 
 #if defined(USE_DX9)
-        float _w = float(Device.dwWidth);
-        float _h = float(Device.dwHeight);
+        float _w = float(RDEVICE.dwWidth);
+        float _h = float(RDEVICE.dwHeight);
         float o_w = (.5f / _w);
         float o_h = (.5f / _h);
         Fmatrix mTexelAdjust =
@@ -221,7 +226,7 @@ class cl_times : public R_constant_setup
 {
     void setup(CBackend& cmd_list, R_constant* C) override
     {
-        float t = Device.fTimeGlobal;
+        float t = RDEVICE.fTimeGlobal;
         cmd_list.set_c(C, t, t * 10, t / 10, _sin(t));
     }
 };
@@ -232,7 +237,7 @@ class cl_eye_P : public R_constant_setup
 {
     void setup(CBackend& cmd_list, R_constant* C) override
     {
-        Fvector& V = Device.vCameraPosition;
+        Fvector& V = RDEVICE.vCameraPosition;
         cmd_list.set_c(C, V.x, V.y, V.z, 1.f);
     }
 };
@@ -243,7 +248,7 @@ class cl_eye_D : public R_constant_setup
 {
     void setup(CBackend& cmd_list, R_constant* C) override
     {
-        Fvector& V = Device.vCameraDirection;
+        Fvector& V = RDEVICE.vCameraDirection;
         cmd_list.set_c(C, V.x, V.y, V.z, 0.f);
     }
 };
@@ -254,7 +259,7 @@ class cl_eye_N : public R_constant_setup
 {
     void setup(CBackend& cmd_list, R_constant* C) override
     {
-        Fvector& V = Device.vCameraTop;
+        Fvector& V = RDEVICE.vCameraTop;
         cmd_list.set_c(C, V.x, V.y, V.z, 0.f);
     }
 };
@@ -348,8 +353,8 @@ static class cl_screen_res : public R_constant_setup
 {
     void setup(CBackend& cmd_list, R_constant* C) override
     {
-        cmd_list.set_c(C, (float)Device.dwWidth, (float)Device.dwHeight, 1.0f / (float)Device.dwWidth,
-            1.0f / (float)Device.dwHeight);
+        cmd_list.set_c(C, (float)RDEVICE.dwWidth, (float)RDEVICE.dwHeight, 1.0f / (float)RDEVICE.dwWidth,
+            1.0f / (float)RDEVICE.dwHeight);
     }
 } binder_screen_res;
 

src/Layers/xrRender/DetailFormat.h

@@ -54,6 +54,7 @@
     u16*            indices;
 */
 
+class EDetailManager;
 #define DO_NO_WAVING 0x0001
 
 class DetailHeader
@@ -115,6 +116,8 @@ class DetailHeader
     u32 slot_count() const { return size_x * size_z; }
     float slot_min_x(int _x) const { return (int(_x) - int(offs_x)) * DETAIL_SLOT_SIZE; }
     float slot_min_z(int _z) const { return (int(_z) - int(offs_z)) * DETAIL_SLOT_SIZE; }
+
+    friend class EDetailManager;
 };
 
 struct DetailPalette