Dreamer-GE

Fast way to render lots of spheres

Mon, 19 Feb 2018 21:22:00 +0200

Sebastian Aaltonen presents a fast method of rendering debug spheres (N*2 triangles, where N is the number of spheres you have).

Full article at: https://gist.github.com/sebbbi/a599d7896aa3ad36642145d54459f32b

Efficient Data Structures for Cache Architectures

Fri, 16 Feb 2018 20:17:00 +0200

How to code high-performance string data structures and data management algorithms by Dr. Nikolas Askitis.

Full article at: https://github.com/naskitis/Efficient-Data-Structures-for-Cache-Architectures

How C++ Debuggers work - Simon Brand - Meeting C++ 2017

Fri, 16 Feb 2018 20:10:00 +0200

Debuggers are one of the most important tools in the belt of any developer, but they are often seen as a magic black box. This is compounded by the lack of available literature, especially when compared to other toolchain components like compilers. This talk aims to demystify debuggers by showing how the utilities you use every day actually work.

Full video at: https://www.youtube.com/watch?v=Q3Rm95Mk03c

Determining Triangle Geometry in Fragment Shaders

Thu, 15 Feb 2018 22:05:00 +0200

When doing GPU programming, it’s sometimes useful to determine the positions of the vertices of the current triangle primitive in a fragment shader. It turns out, though, that there is a relatively straightforward solution without any extra shader stages using the standard derivative functions dFdx and dFdy.

Full article at: https://pcwalton.github.io/2018/02/14/determining-triangle-geometry-in-fragment-shaders.html

Bicubic Filtering in Fewer Taps

Wed, 17 May 2017 19:32:00 +0300

A more detailed explanation of GPU Gems 2, chapter 20, Fast Third-Order Texture Filtering.

Full article at: https://vec3.ca/bicubic-filtering-in-fewer-taps/

Tutorial of Ray Casting, Ray Tracing and Ray Marching

Mon, 27 Jun 2016 00:03:00 +0300

As GPU power is becoming significantly better than CPU, ray casting / tracing and ray marching is widely used in 4k intros and demoscenes to create 3D (interactive) graphics.

Full article at: https://blog.ruofeidu.com/tutorial-of-ray-casting-ray-tracing-and-ray-marching/

Experimentation framework for probe-based lighting

Mon, 27 Jun 2016 00:03:00 +0300

Experimentation framework for probe-based lighting: https://github.com/kayru/Probulator

Material Studies

Sun, 05 Jun 2016 21:37:00 +0300

A study on different materials and the parameters required to obtain them using Houdini.

Metals: https://www.behance.net/gallery/35636521/Material-Studies-Metals

Direct3D 12.0 quick reference guide

Sun, 03 Apr 2016 22:01:00 +0300

Guide source and pdf: https://github.com/alessiot89/D3D12QuickRef/

Optimizing the Graphics Pipeline with Compute

Wed, 30 Mar 2016 01:58:00 +0300

A presentation on how the compute power of the console and PC GPUs can be used to improve the triangle throughput beyond the limits of the fixed function hardware: https://www.frostbite.com/2016/03/optimizing-the-graphics-pipeline-with-compute/

Bindless texturing for deferred rendering and decals

Wed, 30 Mar 2016 01:58:00 +0300

Using bindless resources in D3D12 and Vulkan instead of the slot based system: https://mynameismjp.wordpress.com/2016/03/25/bindless-texturing-for-deferred-rendering-and-decals/

floats, bits, and constant expressions

Mon, 28 Mar 2016 23:21:00 +0300

Access the bits that represent an IEEE754 single precision float in a C++14 constant expression: https://brnz.org/hbr/?p=1518

Deep Dive: How VXAO, Frustum Tracing, & Fluid Combustibles Work

Mon, 28 Mar 2016 22:14:00 +0300

NVidia’s GameWorks team is announcing five new technologies :

* Volumetric Lighting algorithm update
* Voxel-Accelerated Ambient Occlusion (VXAO)
* High-Fidelity Frustum-Traced Shadows (HFTS)
* Flow (combustible fluid, fire, smoke, dynamic grid simulator, and rendering in Dx11/12)
* GPU Rigid Body tech

This article introduces the new technologies and explains how they work at a low-level: https://www.gamersnexus.net/guides/2355-deep-dive-how-vxao-frustum-tracing-and-flow-work

Real Time Point Based Global Illumination by Anatole Duprat

Sun, 27 Mar 2016 21:43:00 +0300

Real Time Point Based Global Illumination Article: https://www.aduprat.com/portfolio/?page=articles/PBGI

Optimizing the Graphics Pipeline with Compute

Wed, 23 Mar 2016 19:33:00 +0200

Limbo developer Playdead has released the source code (via GitHub) for the temporal reprojection anti-aliasing solution used in its upcoming game Inside. Full article at: https://www.gamasutra.com/view/news/268722/Limbo_dev_opensources_its_Unity_5_antialiasing_tech.php

Developing The Northlight Engine

Sun, 20 Mar 2016 21:33:00 +0200

Lessons learned developing the Northlight Engine: http://wili.cc/research/northlight_dx12/

Leapfrog Probing

Tue, 15 Mar 2016 21:52:00 +0200

A strategy for determining the bucket and position of a hash table item:

https://preshing.com/20160314/leapfrog-probing/

Preparing for Real HDR

Mon, 14 Mar 2016 22:12:00 +0200

An interesting article from NVIDIA for taking advantage of the new HDR Displays: https://developer.nvidia.com/preparing-real-hdr

The Transvoxel Algorithm

Mon, 14 Mar 2016 20:34:00 +0200

The Transvoxel Algorithm is a method for seamlessly stitching together neighboring triangle meshes generated from voxel data at differing resolutions so that level of detail (LOD) can be used with large voxel-based datasets such as volumetric terrain in next-generation video games.

https://transvoxel.org/

Bhaskara I's sine approximation formula

Tue, 23 Feb 2016 20:41:00 +0200

Bhaskara I’s sine approximation formula is a rational expression in one variable for the computation of the approximate values of the trigonometric sines.

https://en.wikipedia.org/wiki/Bhaskara_I’s_sine_approximation_formula

Normalized Vector Interpolation

Mon, 22 Feb 2016 21:34:00 +0200

A small description on interpolating normal vectors using Slerp/lerp/nlerp.

https://blog.demofox.org/2016/02/19/normalized-vector-interpolation-tldr/

PNG + sRGB + cutout/decal AA = problematic

Thu, 18 Feb 2016 21:04:00 +0200

A good blog post on the problems of “PNG + sRGB + cutout/decal AA” in realtime rendering with premultipled alpha.

https://www.realtimerendering.com/blog/png-srgb-cutoutdecal-aa-problematic/

Vulkan is here

Tue, 16 Feb 2016 23:44:00 +0200

Khronos launched the Vulkan 1.0 specification on February 16th, 2016 and Khronos members released Vulkan drivers and SDKs on the same day.

“Khronos Vulkan”: https://www.khronos.org/vulkan/
“NVidia Vulkan drivers”: https://developer.nvidia.com/vulkan-driver
“Vulkan @ AMD GpuOpen”: https://gpuopen.com/gaming-product/vulkan/
“Open-Source Vulkan drivers for Intel hardware”: https://01.org/linuxgraphics/blogs/jekstrand/2016/open-source-vulkan-drivers-intel-hardware
“Experience Vulkan graphics and compute at launch on PowerVR GPUs”: https://blog.imgtec.com/powervr/experience-vulkan-graphics-and-compute-at-launch-on-powervr-gpus
“PowerVR Early Access Program”: https://imgtec.com/tools/powervr-early-access-program/
“Vulkan examples using VulKan ToolS (VKTS)”: https://github.com/McNopper/Vulkan

Vulkan articles by NVidia

Sun, 14 Feb 2016 22:40:00 +0200

“Vulkan Memory Management”: https://developer.nvidia.com/vulkan-memory-management
“OpenGL like Vulkan”: https://developer.nvidia.com/opengl-vulkan
“Transitioning from OpenGL to Vulkan”: https://developer.nvidia.com/transitioning-opengl-vulkan

Amazon launches new, free, high-quality game engine: Lumberyard

Wed, 10 Feb 2016 20:20:00 +0200

Today Amazon has both announced and released a new, free game engine derived fomr CryEngine.

Vulkan Programming Guide

Fri, 05 Feb 2016 20:42:00 +0200

Vulkan is a new open standard API by Khronos that offers low-level control of GPUs for graphics and general purpose computation. It has been designed from the ground up around the capabilities of modern hardware.

The Vulkan Programming Guide: The Official Guide to Learning Vulkan book written by AMD’s Graham Sellers and Google’s John Kessenich is now up for pre-orders:

Amazon :

A Phenomenological Scattering Model for Order-Independent Transparency

Thu, 04 Feb 2016 20:32:00 +0200

Translucent objects such as fog, smoke, glass, ice, and liquids are pervasive in cinematic environments because they frame scenes in depth and create visually compelling shots. Unfortunately, they are hard to simulate in real-time and have thus previously been rendered poorly compared to opaque surfaces in games.

This paper introduces the first model for a real-time rasterization algorithm that can simultaneously approximate the following transparency phenomena: wavelength-varying (“colored”) transmission, translucent colored shadows, caustics, partial coverage, diffusion, and refraction. All render efficiently on modern GPUs by using order-independent draw calls and low bandwidth. We include source code for the transparency and resolve shaders.

Paper : https://graphics.cs.williams.edu/papers/TransparencyI3D16/

New Concurrent Hash Maps for C++

Mon, 01 Feb 2016 20:32:00 +0200

Junction, a C++ library that contains several new concurrent maps. It’s BSD-licensed, so you can use the source code freely in any project, for any purpose.

Source : https://preshing.com/20160201/new-concurrent-hash-maps-for-cpp/

Destiny's Multithreaded Rendering Architecture

Wed, 11 Nov 2015 20:43:00 +0200

Bungie’s @mirror2mask breaks down the multithreaded rendering tech that makes Destiny look good:

Multiple-Scattering Microfacet BSDFs with the Smith Model

Wed, 04 Nov 2015 20:22:00 +0200

Source : https://preshing.com/20160201/new-concurrent-hash-maps-for-cpp/

CppCon 2015: Scott Wardle - Memory and C++ debugging at Electronic Arts

Sat, 10 Oct 2015 22:33:00 +0300

Scott Wardle a senior software engineer Electronic Arts will talk about the current memory and C++ debugging setup and tools used in games.

A collection of free images what can be used during unwrapping of 3D models

Tue, 30 Jun 2015 22:23:00 +0300

UVChecker-map is a collection of free images what can be helpful for unwrapping 3D models.

Source: https://github.com/Arahnoid/UVChecker-map

Extracting data from NVIDIA Physx DCC Plugin for 3DS Max.

Fri, 13 Apr 2012 20:49:00 +0300

After working a bit with the NVIDIA PhysX plugin the first question that came into my mind is how do i get my hands on all the scene data from inside the 3DS Max SDK. NVIDIA throws a hint regarding a interface static Interface_ID PX_INTERFACE_ID(0x4e0b7250, 0x16f70e0a) witch should permit access to the internal data. This seem easy at first so lest get into the code and see what happens :) .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//Get our plugin interface
FPInterface* realInterface = GetCOREInterface(PX_INTERFACE_ID);
//Start enumerating all the wonders the plugin interface offers
FPInterfaceDesc* pxDesc = realInterface->GetDesc();
for (int j = 0; j < pxDesc->functions.Count(); ++j)
{
    FPFunctionDef* fd = pxDesc->functions[j];
    if (fd == NULL)
        continue;
    //read function info
    for (int i = 0; i < fd->params.Count(); ++i)
    {
        //read function parameters
    }
}

After a bit of parsing we get a nice list of functions:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
/* ID[5] */int GetPhysXSDKVersion();
/* ID[6] */MCHAR* GetPhysXSDKVersionString();
/* ID[7] */int GetPhysXSDKVersionMajor();
/* ID[8] */int GetPhysXSDKVersionMinor();
/* ID[9] */int GetPhysXSDKVersionBugFix();
/* ID[10] */int GetApexSDKVersion();
/* ID[0] */int InitializePhysX(Value stream);
/* ID[1] */int CreateToolbar();
/* ID[2] */void ShowToolbar(BOOL show);
/* ID[12] */BOOL ShowValidateScene(BOOL automated);
/* ID[13] */BOOL HwAvailable();
/* ID[11] */int GetScreenHeight();
/* ID[14] */float GetSimulationFPS();
/* ID[15] */BOOL PrintSimulationFPS(BOOL onoff);
/* ID[32] */int AddRigidbody(INode* inode);
/* ID[33] */int AddConstraint(INode* node);
/* ID[34] */int AddDistanceJoint(INode* node);
/* ID[35] */BOOL CaptureInitTransform(INode* inode);
/* ID[38] */int SetRigidbodyShapeFlag(INode* inode,TSTR val flagname,BOOL value);
/* ID[36] */int RemoveRigidbody(INode* inode);
/* ID[37] */int RemoveAll();
/* ID[270] */int NotifyBeforeFirstFrame();
/* ID[28] */int ClearInvalidNodes();
/* ID[29] */int Simulate(float deltat);
/* ID[30] */int SetSimulationSubSteps(int numSteps);
/* ID[31] */int SimulationReset();
/* ID[134] */void SetSimulationState(int state);
/* ID[135] */int GetSimulationState();
/* ID[136] */BOOL IsSimulating();
/* ID[23] */int ExportPhysXScene(MCHAR* filename,MCHAR* extension);
/* ID[24] */int ExportPhysXProjectFile(MCHAR* physxProjectPath,MCHAR* physxProjectName);
/* ID[25] */int ExportPhysXProject(MCHAR* physxProjectPath,MCHAR* physxProjectName,MCHAR* fbxFileName);
/* ID[26] */int PrepExportPhysXScene(BOOL isexportphysx,MCHAR* extension);
/* ID[27] */int PrepExportAPEXClothing(BOOL exportAPEXClothing,MCHAR* apExtension,BOOL useModelSpace,float scale,BOOL addHulls,BOOL exportCTW,BOOL exportFBX,BOOL exportSelected,BOOL launchViewer,BOOL reverseWinding,BOOL omitMeshSubpartName);
/* ID[39] */Point3 ref GetLinearVelocity(INode* inode);
/* ID[40] */Point3 ref GetAngularVelocity(INode* inode);
/* ID[41] */int SetLinearVelocity(INode* inode,Point3 ref linearvelocity);
/* ID[42] */int SetAngularVelocity(INode* inode,Point3 ref angularvelocity);
/* ID[43] */Point3 ref GetGlobalPosition(INode* inode);
/* ID[44] */int SetGlobalPosition(INode* inode,Point3 ref position);
/* ID[45] */Matrix3 ref GetGlobalPose(INode* inode);
/* ID[46] */int SetGlobalPose(INode* inode,Matrix3 ref pose);
/* ID[47] */float GetMass(INode* inode);
/* ID[48] */float SetMass(INode* inode,float value);
/* ID[66] */float GetDynamicFriction(INode* inode);
/* ID[67] */float GetStaticFriction(INode* inode);
/* ID[68] */float GetRestitution(INode* inode);
/* ID[69] */int SetDynamicFriction(INode* inode,float value);
/* ID[70] */int SetStaticFriction(INode* inode,float value);
/* ID[71] */int SetRestitution(INode* inode,float value);
/* ID[72] */BOOL SaveMaterial(MCHAR* filename,float staticFriction,float dynamicFriction,float bounciness,int density);
/* ID[73] */float LoadMaterialDynFric(MCHAR* filename);
/* ID[74] */float LoadMaterialStaticFric(MCHAR* filename);
/* ID[75] */float LoadMaterialBounciness(MCHAR* filename);
/* ID[76] */int LoadMaterialDensity(MCHAR* filename);
/* ID[77] */INode* CreateBoundingBox(INode* inode);
/* ID[78] */INode* CreateBoundingSphere(INode* inode);
/* ID[79] */INode* CreateBoundingCapsule(INode* inode);
/* ID[80] */INode* CreateBoundingCapsuleFromPoints(Matrix3 poseTransform,Tab<float ref> points);
/* ID[81] */INode* CreateBoundingShapeConvex(INode* inode,int vertLimit,float inflation,int style);
/* ID[82] */Mesh CreateBoundingConvex(INode* inode,int vertLimit,float inflation);
/* ID[83] */Mesh CreateBoundingConvexFromNodes(Tab<INode* ref> inodes,int vertLimit,float inflation);
/* ID[84] */BOOL SetAsDynamic(INode* inode,BOOL onoff);
/* ID[85] */BOOL SetSleepState(INode* inode,BOOL onoff);
/* ID[86] */BOOL SetRBParam(INode* inode,MCHAR* paramName,MCHAR* paramValue);
/* ID[87] */MCHAR* GetRBParam(INode* inode,MCHAR* paramName);
/* ID[88] */BOOL SetRBShapeParam(INode* inodeRB,INode* inodeShape,MCHAR* paramName,MCHAR* paramValue);
/* ID[89] */BOOL GetRBShapeParam(INode* inodeRB,INode* inodeShape,MCHAR* paramName);
/* ID[90] */BOOL SetConstraintParam(INode* inode,MCHAR* paramName,MCHAR* paramValue);
/* ID[91] */BOOL GetConstraintParam(INode* inode,MCHAR* paramName);
/* ID[3] */int DebugPrint();
/* ID[4] */void DescribeMe();
/* ID[16] */int SetSDKParameter(TSTR val paramName,float value);
/* ID[17] */float GetSDKParameter(TSTR val paramName);
/* ID[18] */int SetSDKDefaultParameter(TSTR val paramName);
/* ID[50] */Mesh CreateConvexHull(Mesh mesh,int vertlimit,float inflation);
/* ID[51] */Mesh CreateConvexFromPoints(Tab<float ref> points,int vertlimit,float inflation);
/* ID[19] */Point3 val GetGravity();
/* ID[20] */int SetGravity(Point3 val gravity);
/* ID[21] */float SetGeometryScale(float scaleRate);
/* ID[22] */float GetGeometryScale();
/* ID[54] */BOOL SetUseContactReport(BOOL OnOff);
/* ID[55] */int GetContactsCount();
/* ID[56] */BOOL SelectFirstContact();
/* ID[57] */BOOL GetNextContact();
/* ID[58] */Point3 val GetContactForce(index_int index);
/* ID[59] */Point3 val GetContactPoint(index_int index);
/* ID[60] */INode* GetContactNode0(index_int index);
/* ID[61] */INode* GetContactNode1(index_int index);
/* ID[62] */float SetContactFilter(float force);
/* ID[63] */float GetContactFilter();
/* ID[64] */int FindSleepingActors();
/* ID[65] */INode* GetSleepingActor(int index);
/* ID[92] */BOOL RBBroken(INode* inode);
/* ID[93] */int PrintTM(INode* inode);
/* ID[94] */int PrintNodeParams(INode* inode);
/* ID[107] */INode* RagdollGetRootBone(INode* inode);
/* ID[106] */BOOL IsRagdollNode(INode* inode);
/* ID[108] */BOOL PhysiqueLoad(INode* inode);
/* ID[109] */int PhysiqueGetNumBones(INode* inode);
/* ID[110] */INode* PhysiqueGetBone(INode* inode,int boneIndex);
/* ID[111] */int PhysiqueGetNumBoneVertices(INode* inode,INode* boneNode);
/* ID[112] */Point3 val PhysiqueGetBoneVertex(INode* inode,INode* boneNode,int verticeIndex);
/* ID[102] */BOOL IsConvex(INode* inode);
/* ID[103] */float CalcVolume(INode* inode);
/* ID[104] */BOOL ConnectPVD(MCHAR* hostName);
/* ID[96] */int SaveClothingTemplate(MCHAR* filePath,MCHAR* fileName);
/* ID[95] */int LoadClothingTemplate(MCHAR* filePath);
/* ID[97] */int RebuildSelectedClothingNode();
/* ID[98] */int SaveAPEXClothing(MCHAR* filePath,BOOL useModelSpace,float scale,BOOL addHulls,BOOL exportCTW,BOOL exportFBX,BOOL exportCTP,BOOL exportSelected,BOOL launchViewer,BOOL reverseWinding,BOOL omitMeshSubpartName);
/* ID[105] */void SetButtonCheck(int id,BOOL value);
/* ID[99] */void DestroyPhysX();
/* ID[113] */BOOL ParseSkinInfo(INode* inode,float weightThreshold);
/* ID[114] */Tab<float val> GetVerticesFromSkinnedBone(INode* inode);
/* ID[115] */int GetVerticesCountFromSkinnedBone(INode* inode);
/* ID[116] */BOOL ReleaseSkinInfo();
/* ID[117] */BOOL HaveBoneFloatLimitControl(INode* inode,MCHAR* block);
/* ID[118] */MCHAR* GetBoneFloatLimitValue(INode* inode,MCHAR* block,MCHAR* param);
/* ID[119] */BOOL IsBone(INode* inode);
/* ID[120] */BOOL IsBiped(INode* inode);
/* ID[121] */BOOL IsBipedRoot(INode* inode);
/* ID[122] */BOOL IsBipedFootsteps(INode* inode);
/* ID[123] */void BipedSetKeys(BOOL setKeys);
/* ID[100] */int GetSolverIterations();
/* ID[101] */int SetSolverIterations(int count);
/* ID[124] */BOOL CreateGround(float position,Point3 ref normal);
/* ID[125] */BOOL RemoveGround();
/* ID[128] */BOOL SetRBDisplayMaterial(Mtl* dynamicMat,Mtl* kinematicMat,Mtl* staticMat);
/* ID[130] */Matrix3 val GetBonePose(INode* inode);
/* ID[131] */BOOL LoadRagdollHelperMesh(Mesh val mesh);
/* ID[132] */BOOL SetNullCM();
/* ID[133] */BOOL RemoveNullCM();
/* ID[137] */BOOL ReadSystemUnit(int type,float scale);
/* ID[138] */BOOL CopyRigidbody(INode* fromNode,INode* toNode);
/* ID[139] */int GetRBMeshCount(INode* inode);
/* ID[140] */Matrix3 ref GetRBMeshTM(INode* inode,int meshIndex);
/* ID[141] */int SetRBMeshTM(INode* inode,int meshIndex,Matrix3 ref pose);
/* ID[142] */int AddRBMesh(INode* inode);
/* ID[143] */BOOL DeleteRBMesh(INode* inode,int meshIndex);
/* ID[144] */BOOL ClipboardCopyRBMesh(INode* inode,int meshIndex);
/* ID[145] */BOOL ClipboardPasteRBMesh(INode* inode);
/* ID[146] */MCHAR* GetRBMeshName(INode* inode,int meshIndex);
/* ID[147] */int SetRBMeshName(INode* inode,int meshIndex,MCHAR* meshName);
/* ID[148] */MCHAR* GetRBMeshType(INode* inode,int meshIndex);
/* ID[149] */int SetRBMeshType(INode* inode,int meshIndex,int meshType);
/* ID[150] */float GetRBMeshRadius(INode* inode,int meshIndex);
/* ID[151] */int SetRBMeshRadius(INode* inode,int meshIndex,float radius);
/* ID[152] */float GetRBMeshLength(INode* inode,int meshIndex);
/* ID[153] */int SetRBMeshLength(INode* inode,int meshIndex,float Length);
/* ID[154] */float GetRBMeshWidth(INode* inode,int meshIndex);
/* ID[155] */int SetRBMeshWidth(INode* inode,int meshIndex,float Width);
/* ID[156] */float GetRBMeshHeight(INode* inode,int meshIndex);
/* ID[157] */int SetRBMeshHeight(INode* inode,int meshIndex,float Height);
/* ID[158] */INode* GetRBMeshCustomNode(INode* inode,int meshIndex);
/* ID[159] */int SetRBMeshCustomNode(INode* inode,int meshIndex,INode* CustomNode);
/* ID[160] */int GetRBMeshVertexLimit(INode* inode,int meshIndex);
/* ID[161] */int SetRBMeshVertexLimit(INode* inode,int meshIndex,int VerticeLimit);
/* ID[162] */float GetRBMeshInflation(INode* inode,int meshIndex);
/* ID[163] */int SetRBMeshInflation(INode* inode,int meshIndex,float Inflation);
/* ID[164] */Mesh GetRBMeshShape(INode* inode,int meshIndex);
/* ID[165] */BOOL SetRBMeshShape(INode* inode,int meshIndex,Mesh newMesh);
/* ID[166] */BOOL GetRBMeshOverrideMasterMat(INode* inode,int meshIndex);
/* ID[167] */BOOL SetRBMeshOverrideMasterMat(INode* inode,int meshIndex,BOOL overrideIt);
/* ID[126] */float SetMeterToSystemUnit(float newValue);
/* ID[127] */float GetMeterToSystemUnit();
/* ID[181] */BOOL StartIndirectDrag(INode* attach);
/* ID[182] */BOOL OnIndirectDrag(Point3 ref mousepos);
/* ID[183] */BOOL EndIndirectDrag();
/* ID[180] */SClass_ID GetObjectClass(INode* node);
/* ID[184] */BOOL IsApexAvailable();
/* ID[190] */int MaterialGetCount();
/* ID[191] */int MaterialGetId(int matIndex);
/* ID[192] */int MaterialGetType(int matId);
/* ID[193] */BOOL MaterialIsLocked(int matId);
/* ID[194] */int MaterialFind(MCHAR* ParamName);
/* ID[195] */int MaterialCreate(int type);
/* ID[196] */BOOL MaterialRemove(int matId);
/* ID[197] */MCHAR* MaterialGetParam(int matId,MCHAR* ParamName);
/* ID[198] */int MaterialSetParam(int matId,MCHAR* ParamName,MCHAR* ParamValue);
/* ID[199] */void RagdollRegenerate(INode* ragdoll,Tab<INode* ref> bones);
/* ID[200] */void RagdollAddBone(INode* ragdoll,INode* boneNode);
/* ID[201] */void RagdollRemoveBone(INode* ragdoll,INode* boneNode);
/* ID[202] */BOOL RagdollGroupBones(INode* ragdoll,Tab<INode* ref> bones);
/* ID[203] */BOOL RagdollSave(INode* ragdoll,MCHAR* filename);
/* ID[204] */BOOL RagdollLoad(INode* ragdoll,MCHAR* filename);
/* ID[205] */BOOL VisualizerGetEnabled();
/* ID[206] */void VisualizerSetEnabled(BOOL flag);
/* ID[207] */float VisualizerGetScale();
/* ID[208] */float VisualizerSetScale(float newScale);
/* ID[209] */int VisualizerGetPhysXParamCount();
/* ID[210] */MCHAR* VisualizerGetPhysXParamName(int index);
/* ID[211] */int VisualizerGetPhysXParam(MCHAR* paramName);
/* ID[212] */BOOL VisualizerSetPhysXParam(MCHAR* paramName,BOOL flag);
/* ID[213] */int VisualizerGetApexParamCount();
/* ID[214] */MCHAR* VisualizerGetApexParamName(int index);
/* ID[215] */int VisualizerGetApexParam(MCHAR* paramName);
/* ID[216] */BOOL VisualizerSetApexParam(MCHAR* paramName,BOOL flag);
/* ID[186] */int GetPMVisibleForRigidBodies();
/* ID[185] */void SetPMVisibleForRigidBodies(int visible);
/* ID[187] */void ProfilerBegin(MCHAR* name);
/* ID[188] */void ProfilerEnd(MCHAR* name);
/* ID[189] */void ProfilerDump();
/* ID[217] */INode* CreateRagdollHelper();
/* ID[218] */BOOL SupportMultiThread();
/* ID[219] */BOOL UseMultiThread(BOOL onOff);
/* ID[220] */BOOL IsMultiThreadOn();
/* ID[221] */BOOL SupportHardwareScene();
/* ID[222] */BOOL UseHardwareScene(BOOL onOff);
/* ID[223] */BOOL IsHardwareSceneOn();
/* ID[224] */void UnitTest_MaterialCreate(int type,MCHAR* name);
/* ID[225] */BOOL UnitTest_MaterialFind(MCHAR* name);
/* ID[226] */void UnitTest_MaterialDelete(MCHAR* type);
/* ID[227] */void UnitTest_MaterialAssign(INode* node,MCHAR* name);
/* ID[228] */MCHAR* UnitTest_MaterialPick(INode* node);
/* ID[229] */void OpenHelpFile();
/* ID[230] */void PhysXPanelTooltip();
/* ID[231] */void SetCCDMotionThreshold(float ccdMotionThreshold);
/* ID[232] */int GetPhysXPluginCount();
/* ID[233] */int GetPhysXPluginVersion(int Index);
/* ID[234] */MCHAR* GetPhysXPluginVersionString(int Index);
/* ID[235] */int GetPhysXPluginVersionMajor(int Index);
/* ID[236] */int GetPhysXPluginVersionMinor(int Index);
/* ID[237] */int GetPhysXPluginVersionBugFix(int Index);
/* ID[238] */BOOL UsePhysXPlugin(int Index);
/* ID[239] */void DetachPhysX();
/* ID[240] */void AttachPhysX();
/* ID[245] */MCHAR* GetScriptPath();
/* ID[246] */bool IsAutodeskVersion();
/* ID[242] */MCHAR* GetPluginCompanyName();
/* ID[243] */void SetAnimationState(BOOL state);
/* ID[244] */BOOL GetAnimationState();
/* ID[247] */void CreateViewer();
/* ID[250] */void PreCreateViewer();
/* ID[251] */void PostCreateViewer();
/* ID[248] */MCHAR* GetPluginBuild();
/* ID[249] */void ShowAboutDialog();
/* ID[252] */int GetBehaviorReason();
/* ID[253] */BOOL SetBehaviorReason(int mode);
/* ID[254] */BOOL GetBakedFlag(INode* inode);
/* ID[255] */BOOL SetBakedFlag(INode* inode,BOOL isBaked);
/* ID[256] */Matrix3 val GetInitialPose(INode* inode);
/* ID[257] */void SetInitialPose(INode* inode,Matrix3 ref initialPose);
/* ID[258] */BOOL CaptureInitTransforms(Tab<INode* ref> nodes);
/* ID[259] */BOOL ShouldViewerSync();
/* ID[260] */int GetViewerCommand();
/* ID[261] */int SetViewerCommand(int command);
/* ID[262] */void CheckViewerState();
/* ID[263] */void UpdateViewerPlayback();
/* ID[264] */int GetVirtualScreenX();
/* ID[265] */int GetVirtualScreenY();
/* ID[266] */void DumpContentCore(MCHAR* file,int Type);
/* ID[269] */void SetShapePerElement(BOOL shapePerElement);
/* ID[271] */INode* CreateDestruction(Tab<INode* ref> nodes);
/* ID[272] */BOOL GetExporterMode(int Parameter);
/* ID[273] */BOOL SetExporterMode(int Parameter,BOOL onOff);

After exposing this wonderful interface we notice we have access to mostly everything physics regarded. Well NVIDIA fails to provide 2 things:
1. A simulation is required to run before any of the interface returns anything witch can be started manually.

1
2
ExecuteMAXScriptScript(_M("PxResetPhysXScene()"));
ExecuteMAXScriptScript(_M("PxCreatePhysXScene()"));

2. NVIDIA failed to provide a GetRigidBodyType for a Node so that we know if we are dealing with a STATIC/DYNAMIC/KINEMATIC node and the hardcore version is to call MaxScript once again. A call to PxGetNodeType should solve our problem but it involves writhing a bit more uglier code than a simple interface call.

All the pieces are now in place and with a bit more work i will started benefiting the same luxuries that UE3 engine have when exporting this data. I hope this info helps a few more people get a head start in getting a more direct transition from the CAD software to your game engine.

3DS Max - skinning information

Thu, 16 Feb 2012 15:00:00 +0200

Lately i found some time to work on my game engine and i thought that skinning is a must have feature. So before grabbing the bulls by the horns and writhing shaders to multiply matrices the first question that pop up is “Where does 3DS Max keeps his skinning data? What does he offer us?”.

By consulting the SDK i found out about the existence of the classes ISkin and ISkin2. Everything looks easy till here, we have our object, we have our I_SKIN interface, what could be so hard in in calling our object for a interface?

1
obj->GetInterface(I_SKIN);

In reality things aren’t that simple, and after finding out that something that seemed logical at first glance returns a NULL pointer it’s back to the drawing board. Where is the skin if not inside the object?

Since the SDK didn’t offer any samples except for the IGame class Google remained my only alternative of discovering the mysteries of I_SKIN. So after a long search here we are with the answer:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//We need to get our reference object using one of the next 2 function from the current Node
Object* xobj = node->GetObjectRef();
Object* xobj = node->GetObjOrWSMRef();
//If the object has a super class of the type Derived Object then type cast it
IDerivedObject* derivedObj = NULL;
if (xobj->SuperClassID() == GEN_DERIVOB_CLASS_ID)
    derivedObj = static_cast<IDerivedObject*>(xobj);

//The IDerivedObject class actually holds the entire stack of modifiers from max so we need to search for a SKIN modifier
//Once we find the SKIN_CLASSID we can get use GetInterface on the modifier to obtain the ISkin interface
for(int i = 0; i < derivedObj->NumModifiers(); ++i)
{
  Modifier *pModifier = derivedObj->GetModifier(i);
  if (pModifier == NULL || pModifier->ClassID() != SKIN_CLASSID)
    continue;
  skin = (ISkin*)pModifier->GetInterface(I_SKIN);
  break;
}

//Using the ISkin we can get the ISkinContextData based on the modifier node
if (skin != NULL)
  skinContextData = (ISkinContextData*)skin->GetContextInterface(node);

Extracting all the necessary data from:

1
2
3
Mesh* mesh;
ISkin* skin;
ISkinContextData *skinContextData;

shouldn’t be that complicated once you know what you need (bones/weights/etc) but from my point of view 3DS Max should really invest a bit more time in their SDK samples since something like getting the ISkin interface can be really obscure as you can see from the code above.

GPU Driver hangs.

Sun, 28 Aug 2011 17:07:00 +0300

Everybody working in the GPU shader coding business has experienced Driver Hangs/BSOD’s/System reboots due to some infinite loop/typos or other bad behaviors from the WIP Shaders.

As a first measure of precaution i think it should be out of the question that we should make sure we use the latest driver for our hardware.

In order to improve efficiency sometimes the hardware manufacturer can decide to skip various safety checks (like out of bounds access). Luckily for the DirectX users that a switch to a REFERENCE device can return most of the checks back and aldo in some cases we will suffer a big speed penalty. A frame might take quite a few minutes to render but at least our software will run till the point of telling us a proper error message.

For the non-DirectX users or the people that a REF device is unacceptable Windows Vista SP1/Windows 7 comes to the rescue with a new safety feature named “Timeout Detection and Recovery of GPUs through WDDM”. Basically if the GPU driver doesn’t respond for a X period of time it get reloaded. What you might not know is that this behavior is controlled by a registry key and some programs can alter it (with your consent in the NVIDIA Parallel Nsight case) . Now if we uninstall such programs and forget to restore the feature or simply have a bad value there by some unexplained reason the Microsoft MSDN comes to our rescue with a full explanation of the system https://msdn.microsoft.com/en-us/windows/hardware/gg487368.aspx

Developing with Graphics technologies can sometimes have its painful moments but with a few tricks like these we can pass another day in development without having to constantly reboot our pc’s each time we test something.