Page History

public_api.proto

PublicApi.cs

PublicApiGrpc.cs

service ApiServer {

rpc GetProjectName (GetProjectNameRequest) returns (GetProjectNameResponse);

rpc GetProjectChangedNotificationStream(GetProjectChangedNotificationStreamRequest) returns (stream ProjectChangedNotification);

rpc GetViews(GetViewsRequest) returns (GetViewsResponse);

rpc SelectView(SelectViewRequest) returns (SelectViewResponse);

rpc GetProperties(GetPropertiesRequest) returns (GetPropertiesResponse);

rpc GetProperty(GetPropertyRequest) returns (GetPropertyResponse);

rpc SetProperty(SetPropertyRequest) returns (SetPropertyResponse);

rpc ExportVRScene(ExportVRSceneRequest) returns (ExportVRSceneResponse);

rpc GetVRayMaterials(GetVRayMaterialsRequest) returns (GetVRayMaterialsResponse);

rpc SaveVRayMaterialToFile (SaveVRayMaterialToFileRequest) returns (SaveVRayMaterialToFileResponse);

}

GetProjectName

GetProjectNameRequest

GetProjectNameResponse

message GetProjectNameRequest {

google.protobuf.Empty empty = 1;

}

message GetProjectNameResponse {

bool success_status = 1;
string message = 2;
string project_name = 3;

}

GetProjectChangedNotificationStream

GetProjectChangedNotificationStreamRequest

ProjectChangedNotification

message GetProjectChangedNotificationStreamRequest {

google.protobuf.Empty empty = 1;

}

message ProjectChangedNotification {

string project_name = 1;

}

GetViews

GetViewsRequest

GetViewsResponse

message GetViewsRequest {

google.protobuf.Empty empty = 1;

}

message GetViewsResponse {

bool success_status = 1;
string message = 2;
ViewMap view_map = 3;

}

message ViewMap {

map<string, View> values = 1;

}

message View {

string unique_id = 1;
string name = 2;

}

SelectView

SelectViewRequest

SelectViewResponse

message SelectViewRequest {

string unique_id = 1;

}

GetViews

message SelectViewResponse {

bool success_status = 1;
string message = 2;

}

GetProperties

GetPropertiesRequest

GetPropertiesResponse

message GetPropertiesRequest {

google.protobuf.Empty empty = 1;

}

message GetPropertiesResponse {

bool success_status = 1;
string message = 2;
PropertyMap property_map = 3;

}

message PropertyMap {

map<string, Property> values = 1;

}

message Property {

string unique_name = 1;
string readable_name = 2;
string type = 3;
PropertyCategory category = 4;
PropertyValue value = 5;

}

enum PropertyCategory {

Global = 0;
Material = 1;
Environment = 2;
Camera = 3;
Local = 4;
Swarm = 5;
Channel = 6;
Proxy = 7;
VRayMaterial = 8;

};

message PropertyValue {

oneof value
{

bool bool_value = 1;
int32 int_value = 2;
float float_value = 3;
string string_value = 4;

LightingAnalysisQuantity LightingAnalysisQuantity_value = 5;
LightingAnalysisScale LightingAnalysisScale_value = 6;
LightingAnalysisDisplay LightingAnalysisDisplay_value = 7;
DenoiserMode DenoiserMode_value = 8;
DenoiserEngine DenoiserEngine_value = 9;
DenoiserRadiusType DenoiserRadiusType_value = 10;
VRayRenderEngine VRayRenderEngine_value = 11;
VRayResolutionRatio VRayResolutionRatio_value = 12;
VRayResolutionDPIType VRayResolutionDPIType_value = 13;
VRayResolutionPrinterUnit VRayResolutionPrinterUnit_value = 14;
EnvironmentType EnvironmentType_value = 15;
ScreenPlacementType ScreenPlacementType_value = 16;
BackgroundType BackgroundType_value = 17;
VRaySceneQuality VRaySceneQuality_value = 18;
VRayImageSamplerType VRayImageSamplerType_value = 19;
VRayGIEngine VRayGIEngine_value = 20;
VRayLightEvaluation VRayLightEvaluation_value = 21;
VRayCameraMode VRayCameraMode_value = 22;
VRayCameraStereoLayout VRayCameraStereoLayout_value = 23;
VRayCameraFocusSource VRayCameraFocusSource_value = 24;
LightMixGroupBy LightMixGroupBy_value = 25;

AColor AColor_value = 26;
Color Color_value = 27;

}

}

GetProperty

GetPropertyRequest

GetPropertyResponse

message GetPropertyRequest {

string unique_name = 1;

}

message GetPropertyResponse {

bool success_status = 1;
string message = 2;
Property property = 3;

}

SetProperty

SetPropertyRequest

SetPropertyResponse

message SetPropertyRequest {

string unique_name = 1;
PropertyValue value = 2;

}

message SetPropertyResponse {

bool success_status = 1;
string message = 2;

}

ExportVRScene

ExportVRSceneRequest

ExportVRSceneResponse

message ExportVRSceneRequest {

string export_file_path = 1;
bool export_compressed = 2;
bool export_hex_format = 3;
bool export_as_archive = 4;

}

message ExportVRSceneResponse {

bool success_status = 1;
string message = 2;

}

GetVRayMaterials

GetVRayMaterialsRequest

GetVRayMaterialsResponse

message GetVRayMaterialsRequest {

google.protobuf.Empty empty = 1;

}

message GetVRayMaterialsResponse {

bool success_status = 1;
string message = 2;
repeated string material_names = 3;

}

SaveVRayMaterialToFile

SaveVRayMaterialToFileRequest

SaveVRayMaterialToFileResponse

maps

maps

message SaveVRayMaterialToFileRequest {

string material_name = 1;
string file_path = 2;

}

message SaveVRayMaterialToFileResponse {

bool success_status = 1;
string message = 2;

}

enum LightingAnalysisQuantity {

LuminanceCD = 0;
IlluminanceLX = 1;

}

enum LightingAnalysisScale {

Linear = 0;
Logarithmic = 1;

}

enum LightingAnalysisDisplay {

FalseColors = 0;
GridOverlay = 1;

}

enum DenoiserMode {

ReplaceRGB = 0;
DoNotCalculate = 1;
GenerateChannel = 2;

}

enum DenoiserEngine {

Default = 0;
NVIDIA = 1;

}

enum DenoiserRadiusType {

CustomType = 0;
Mild = 1;
Normal = 2;
Strong = 3;

}

enum VRayRenderEngine {

CPU = 0;
GPU = 4;
RTX = 7;

}

enum VRayResolutionRatio {

Widescreen = 0;
Screen = 1;
Square = 2;
Picture = 3;
Landscape = 4;
Portrait = 5;
CropRegion = 6;
Custom = 7;

}

enum VRayResolutionDPIType {

UnusedVRayResolutionDPIType = 0;
DPI75 = 75;
DPI96 = 96;
DPI150 = 150;
DPI300 = 300;
DPI600 = 600;

}

enum VRayResolutionPrinterUnit {

Inches = 0;
Millimeters = 1;

}

enum EnvironmentType {

Sun = 0;
Dome = 1;
None = 2;

}

enum ScreenPlacementType {

ScreenPlacement = 0;
SphericalPlacement = 1;

}

enum BackgroundType {

NoBackground = 0;
CustomBackground = 1;
RevitBackground = 2;

}

enum VRaySceneQuality {

Draft = 0;
Low = 1;
Medium = 2;
High = 3;
VeryHigh = 4;

}

enum VRayImageSamplerType  {

UnusedVRayImageSamplerType = 0;
Buckets = 1;
Progressive = 3;

}

enum VRayGIEngine {

IrradianceMap = 0;
BruteForce = 2;
LightCache = 3;

}

enum VRayLightEvaluation {

Full = 0;
Adaptive = 2;

}

enum VRayCameraMode {

Standard = 0;
Orthogonal = 7;
SphericalPanorama = 9;
Cube = 10;

}

enum VRayCameraStereoLayout {

UnusedVRayCameraStereoLayout = 0;
SideBySide = 1;
TopBottom = 2;

}

enum VRayCameraFocusSource {

FixedDistance = 0;
FixedPoint = 2;

}

message AColor {

float r = 1;
float g = 2;
float b = 3;
float alpha = 4;

}

message Color {

float r = 1;
float g = 2;
float b = 3;

}

C:\Users\%USERPROFILE%\AppData\Roaming\Chaos Group\V-Ray for Revit 20XX\config.json

XX

apiServers

"apiServers": [

{

"PID": 22920,
"port": 58538

},
{

"PID": 14792,
"port": 58611

}

]

private const int RevitVersion = 2020;
private static readonly string ConfigJsonPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),

$"Chaos Group\\V-Ray for Revit {RevitVersion}", "config.json");

private static int GetServerPort()

{

var runningInRevitAddon = true;

using (var reader = new StreamReader(ConfigJsonPath))
{

var json = JObject.Parse(reader.ReadToEnd());

var apiServers = json["apiServers"] as JArray;

if (apiServers != null && apiServers.Count > 0)
{

JObject apiServer;
if (runningInRevitAddon)
{

apiServer = apiServers.OfType<JObject>().SingleOrDefault(jo => (int)jo["PID"] == Process.GetCurrentProcess().Id);

}
else
{

apiServer = apiServers.OfType<JObject>().FirstOrDefault();

}

if (apiServer != null)
{

return (int)apiServer["port"];

}

}

}

return -1;

}

config.json

public async Task<bool> ConnectAsync()

{

var serverPort = GetServerPort();
if (serverPort != -1)
{

this.channel = new Channel($"localhost:{serverPort}", ChannelCredentials.Insecure);

var deadline = DateTime.UtcNow.AddSeconds(1);
try
{

await this.channel.ConnectAsync(deadline);

return true;

}
catch (TaskCanceledException)
{

return false;

}

}
else
{

Debug.WriteLine("Public API Server has not started yet!");
return false;

}

}

GetServerPort

public async Task<string> GetProjectNameAsync()
{

try
{

var client = new ApiServerClient(this.channel);
var response = await client.GetProjectNameAsync(new GetProjectNameRequest());
if (response.SuccessStatus)
{

return response.ProjectName;

}
else
{

MessageBox.Show(response.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return string.Empty;

}

}
catch (RpcException e)
{

Debug.WriteLine(e);
return string.Empty;

}

}

ApiServerClient

GetProjectNameResponse

public async Task<IEnumerable<View>> GetViewsAsync()
{

try
{

var client = new ApiServerClient(this.channel);
var response = await client.GetViewsAsync(new GetViewsRequest());
if (response.SuccessStatus)
{

return response.ViewMap.Values.Values;

}
else
{

MessageBox.Show(response.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return Enumerable.Empty<View>();

}

}
catch (RpcException e)
{

Debug.WriteLine(e);
return Enumerable.Empty<View>();

}

}

ApiServerClient

GetViewsRequest

GetViewsResponse

public async Task<bool> SelectViewAsync(string uniqueId)
{

try
{

var client = new ApiServerClient(this.channel);
var response = await client.SelectViewAsync(new SelectViewRequest() { UniqueId = uniqueId });

if (response.SuccessStatus)
{

return true;

}
else
{

MessageBox.Show(response.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return false;

}

}
catch (RpcException e)
{

Debug.WriteLine(e);
return false;

}

}

uniqueId

public async Task<IEnumerable<Property>> GetPropertiesAsync()
{

try
{

var client = new ApiServerClient(this.channel);
var response = await client.GetPropertiesAsync(new GetPropertiesRequest());
if (response.SuccessStatus)
{

return response.PropertyMap.Values.Values;

}
else
{

MessageBox.Show(response.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return Enumerable.Empty<Property>();

}

}
catch (RpcException e)
{

Debug.WriteLine(e);
return Enumerable.Empty<Property>();

}

}

ApiServerClient

GetPropertiesRequest

GetPropertiesResponse

public async Task<Property> GetPropertyAsync(string uniqueName)
{

try
{

var client = new ApiServerClient(this.channel);
var response = await client.GetPropertyAsync(new GetPropertyRequest() { UniqueName = uniqueName });
if (response.SuccessStatus)
{

return response.Property;

}
else
{

MessageBox.Show(response.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return null;

}

}
catch (RpcException e)
{

Debug.WriteLine(e);
return null;

}

}

uniqueName 

 public async Task<bool> SetPropertyAsync(string uniqueName, PropertyValue propertyValue)
{

try
{

var client = new ApiServerClient(this.channel);

var request = new SetPropertyRequest()
{

UniqueName = uniqueName,
Value = propertyValue

};

var response = await client.SetPropertyAsync(request);

if (response.SuccessStatus)
{

return true;

}
else
{

MessageBox.Show(response.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return false;

}

}
catch (RpcException e)
{

Debug.WriteLine(e);
return false;

}

}

uniqueName

Get all properties

propertyValue

PropertyValue

var uniqueName = "GlobalArtificialLightsEnabled";
var propertyValue = new PropertyValue() { BoolValue = true };
SetPropertyAsync(uniqueName, propertyValue);

var uniqueName = "customResolutionWidth";
var propertyValue = new PropertyValue() { IntValue = 800 };
SetPropertyAsync(uniqueName, propertyValue);

var uniqueName = "GlobalArtificialLightsIntensity";
var propertyValue = new PropertyValue() { FloatValue = 2.0f };
SetPropertyAsync(uniqueName, propertyValue);

var uniqueName = "backgroundImagePath";
var propertyValue = new PropertyValue() { StringValue = "C:\myimage.png" };
SetPropertyAsync(uniqueName, propertyValue);

var uniqueName = "environmentType";
var propertyValue = new PropertyValue() { EnvironmentTypeValue = EnvironmentType.Dome };
SetPropertyAsync(uniqueName, propertyValue);

var uniqueName = "EnvFogColor";
var propertyValue = new PropertyValue() { AColorValue = new AColor() { R = 0.5f, G = 0.5f, B = 0.5f, Alpha = 1.0f } };
SetPropertyAsync(uniqueName, propertyValue);

var uniqueName = "SunFilterColor";
var propertyValue = new PropertyValue() { ColorValue = new Color() { R = 0.5f, G = 0.5f, B = 0.5f } };
SetPropertyAsync(uniqueName, propertyValue);

public async Task<Tuple<bool, string>> ExportVRSceneAsync(string exportFilePath, bool exportAsArchive, bool exportCompressed, bool exportHexFormat)

{

try
{

var client = new ApiServerClient(this.channel);
try
{

var response = await client.ExportVRSceneAsync(new ExportVRSceneRequest()
{

ExportFilePath = exportFilePath,
ExportAsArchive = exportAsArchive,
ExportCompressed = exportCompressed,
ExportHexFormat = exportHexFormat

});

// If the export was successfull, response.Message will contain the
// actual file path of the exported V-Ray Scene
return new Tuple<bool, string>(response.SuccessStatus, response.Message);

}
catch (TaskCanceledException e)
{

Debug.WriteLine(e);
return new Tuple<bool, string>(false, e.ToString());

}

}
catch (RpcException e)
{

Debug.WriteLine(e);
await this.ShutdownAsync();
return new Tuple<bool, string>(false, e.ToString());

}

}

ApiServerClient

ExportVRSceneRequest

ExportVRSceneResponse

public async Task<IEnumerable<string>> GetVRayMaterialsAsync()
{

try
{

var client = new ApiServerClient(this.channel);

var response = await client.GetVRayMaterialsAsync(new GetVRayMaterialsRequest());
if (response.SuccessStatus)
{

return response.MaterialNames;

}
else
{

MessageBox.Show(response.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return Enumerable.Empty<string>();

}

}
catch (RpcException e)
{

Debug.WriteLine(e);
return Enumerable.Empty<string>();

}

}

ApiServerClient

GetVRayMaterialsRequest

GetVRayMaterialsResponse

public async Task<Tuple<bool, string>> SaveVRayMaterialToFileAsync(string materialName, string filePath)

{

try
{

var client = new ApiServerClient(this.channel);
try
{

var response = await client.SaveVRayMaterialToFileAsync(new SaveVRayMaterialToFileRequest()
{

MaterialName = materialName,
FilePath = filePath

});

return new Tuple<bool, string>(response.SuccessStatus, response.Message);

}
catch (TaskCanceledException e)
{

Debug.WriteLine(e);
return new Tuple<bool, string>(false, e.ToString());

}

}
catch (RpcException e)
{

Debug.WriteLine(e);
return new Tuple<bool, string>(false, e.ToString());

}

}

ApiServerClient

SaveVRayMaterialToFileRequest

SaveVRayMaterialToFileResponse

public async void ListenForProjectChangedAsync()
{

try
{

var client = new ApiServerClient(this.channel);

using (var call = client.GetProjectChangedNotificationStream(new GetProjectChangedNotificationStreamRequest(), null, null, this.cts.Token))
{

while (await call.ResponseStream.MoveNext())
{

var projectName = call.ResponseStream.Current.ProjectName;
Debug.WriteLine("Project has changed to " + projectName);

}

}

}
catch (RpcException e)
{

Debug.WriteLine(e);

}

}

• Task Parallel Library (TPL)
• https://grpc.io/
• https://grpc.io/docs/languages/csharp/quickstart/
• https://grpc.io/docs/languages/csharp/basics/
• https://grpc.github.io/grpc/csharp/api/Grpc.Core
• https://www.nuget.org/packages/Grpc.Tools/
• https://github.com/grpc